export namespace types {
	
	export class AfterSaleInfo {
	    title: string;
	    img: string;
	    content: string;
	    status: number;
	    outCode: string;
	    orderCode: string;
	    createdTime: string;
	    afterSaleType: number;
	    categoryName: string;
	    typeName: string;
	    createdName: string;
	    contact: string;
	    phone: string;
	    processingPlan: string;
	    processingResult: string;
	    priority: number;
	
	    static createFrom(source: any = {}) {
	        return new AfterSaleInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.title = source["title"];
	        this.img = source["img"];
	        this.content = source["content"];
	        this.status = source["status"];
	        this.outCode = source["outCode"];
	        this.orderCode = source["orderCode"];
	        this.createdTime = source["createdTime"];
	        this.afterSaleType = source["afterSaleType"];
	        this.categoryName = source["categoryName"];
	        this.typeName = source["typeName"];
	        this.createdName = source["createdName"];
	        this.contact = source["contact"];
	        this.phone = source["phone"];
	        this.processingPlan = source["processingPlan"];
	        this.processingResult = source["processingResult"];
	        this.priority = source["priority"];
	    }
	}
	export class AiContentReq {
	    checklistId: number;
	    content: string;
	    organId: number;
	    questionType: string;
	
	    static createFrom(source: any = {}) {
	        return new AiContentReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.checklistId = source["checklistId"];
	        this.content = source["content"];
	        this.organId = source["organId"];
	        this.questionType = source["questionType"];
	    }
	}
	export class UsageInfo {
	    prompt_tokens: number;
	    completion_tokens: number;
	    total_tokens: number;
	
	    static createFrom(source: any = {}) {
	        return new UsageInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.prompt_tokens = source["prompt_tokens"];
	        this.completion_tokens = source["completion_tokens"];
	        this.total_tokens = source["total_tokens"];
	    }
	}
	export class MessageInfo {
	    role: string;
	    content: string;
	
	    static createFrom(source: any = {}) {
	        return new MessageInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.role = source["role"];
	        this.content = source["content"];
	    }
	}
	export class ChoicesInfo {
	    message: MessageInfo;
	    finish_reason: string;
	
	    static createFrom(source: any = {}) {
	        return new ChoicesInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.message = this.convertValues(source["message"], MessageInfo);
	        this.finish_reason = source["finish_reason"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class AiResponsePayload {
	    id: string;
	    questionType: string;
	    choices: ChoicesInfo[];
	    usage: UsageInfo;
	    isUse: number;
	
	    static createFrom(source: any = {}) {
	        return new AiResponsePayload(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.questionType = source["questionType"];
	        this.choices = this.convertValues(source["choices"], ChoicesInfo);
	        this.usage = this.convertValues(source["usage"], UsageInfo);
	        this.isUse = source["isUse"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class AiResponsePayloadList {
	    list: AiResponsePayload[];
	
	    static createFrom(source: any = {}) {
	        return new AiResponsePayloadList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], AiResponsePayload);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class AiResponsePayloadListResp {
	    code: number;
	    msg: string;
	    data: AiResponsePayloadList;
	
	    static createFrom(source: any = {}) {
	        return new AiResponsePayloadListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], AiResponsePayloadList);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ApplyAfterSaleReq {
	    categoryName: string;
	    contact: string;
	    content: string;
	    images: string[];
	    outCode: string;
	    phone: string;
	    problemRecord: string;
	    title: string;
	    typeName: string;
	
	    static createFrom(source: any = {}) {
	        return new ApplyAfterSaleReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.categoryName = source["categoryName"];
	        this.contact = source["contact"];
	        this.content = source["content"];
	        this.images = source["images"];
	        this.outCode = source["outCode"];
	        this.phone = source["phone"];
	        this.problemRecord = source["problemRecord"];
	        this.title = source["title"];
	        this.typeName = source["typeName"];
	    }
	}
	export class Assets {
	    nowIntegral: number;
	    accumulateIntegral: number;
	    consumptionIntegral: number;
	    nowAmount: number;
	    accumulateAmount: number;
	
	    static createFrom(source: any = {}) {
	        return new Assets(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.nowIntegral = source["nowIntegral"];
	        this.accumulateIntegral = source["accumulateIntegral"];
	        this.consumptionIntegral = source["consumptionIntegral"];
	        this.nowAmount = source["nowAmount"];
	        this.accumulateAmount = source["accumulateAmount"];
	    }
	}
	export class AuthCaptchaResp {
	    code: number;
	    msg: string;
	    // Go type: struct { CaptchaId string "json:\"captchaId\""; PicPath string "json:\"picPath\""; CaptchaLength int "json:\"captchaLength\""; OpenCaptcha bool "json:\"openCaptcha\"" }
	    data: any;
	
	    static createFrom(source: any = {}) {
	        return new AuthCaptchaResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], Object);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class AuthGetUserOrganElement {
	    organClassificationId: number;
	    organId: number;
	    organName: string;
	
	    static createFrom(source: any = {}) {
	        return new AuthGetUserOrganElement(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.organClassificationId = source["organClassificationId"];
	        this.organId = source["organId"];
	        this.organName = source["organName"];
	    }
	}
	export class AuthGetUserOrganListItem {
	    list: AuthGetUserOrganElement[];
	
	    static createFrom(source: any = {}) {
	        return new AuthGetUserOrganListItem(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], AuthGetUserOrganElement);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class AuthGetUserOrganListResp {
	    code: number;
	    msg: string;
	    data: AuthGetUserOrganListItem;
	
	    static createFrom(source: any = {}) {
	        return new AuthGetUserOrganListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], AuthGetUserOrganListItem);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class AuthLoginReq {
	    username: string;
	    password: string;
	    captcha: string;
	    captchaId: string;
	    organId: number;
	    organClassificationId: number;
	    domValue: string;
	
	    static createFrom(source: any = {}) {
	        return new AuthLoginReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.username = source["username"];
	        this.password = source["password"];
	        this.captcha = source["captcha"];
	        this.captchaId = source["captchaId"];
	        this.organId = source["organId"];
	        this.organClassificationId = source["organClassificationId"];
	        this.domValue = source["domValue"];
	    }
	}
	export class AuthLoginResp {
	    code: number;
	    msg: string;
	    // Go type: struct { Token string "json:\"token\"" }
	    data: any;
	
	    static createFrom(source: any = {}) {
	        return new AuthLoginResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], Object);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class BaseEyeUsageDistance {
	    id: number;
	    code: string;
	    name: string;
	
	    static createFrom(source: any = {}) {
	        return new BaseEyeUsageDistance(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.code = source["code"];
	        this.name = source["name"];
	    }
	}
	export class BaseEyeUsageDistanceList {
	    list: BaseEyeUsageDistance[];
	
	    static createFrom(source: any = {}) {
	        return new BaseEyeUsageDistanceList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], BaseEyeUsageDistance);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class BaseEyeUsageDistanceResp {
	    code: number;
	    msg: string;
	    data: BaseEyeUsageDistanceList;
	
	    static createFrom(source: any = {}) {
	        return new BaseEyeUsageDistanceResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], BaseEyeUsageDistanceList);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class BaseOccupation {
	    id: number;
	    code: string;
	    name: string;
	
	    static createFrom(source: any = {}) {
	        return new BaseOccupation(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.code = source["code"];
	        this.name = source["name"];
	    }
	}
	export class BaseOccupationList {
	    list: BaseOccupation[];
	
	    static createFrom(source: any = {}) {
	        return new BaseOccupationList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], BaseOccupation);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class BaseOccupationResp {
	    code: number;
	    msg: string;
	    data: BaseOccupationList;
	
	    static createFrom(source: any = {}) {
	        return new BaseOccupationResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], BaseOccupationList);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class BaseWorkEnvFor {
	    id: number;
	    code: string;
	    name: string;
	
	    static createFrom(source: any = {}) {
	        return new BaseWorkEnvFor(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.code = source["code"];
	        this.name = source["name"];
	    }
	}
	export class BaseWorkEnvList {
	    list: BaseWorkEnvFor[];
	
	    static createFrom(source: any = {}) {
	        return new BaseWorkEnvList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], BaseWorkEnvFor);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class BaseWorkEnvResp {
	    code: number;
	    msg: string;
	    data: BaseWorkEnvList;
	
	    static createFrom(source: any = {}) {
	        return new BaseWorkEnvResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], BaseWorkEnvList);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CreateCustomerRelativeReq {
	    name: string;
	    baseRelationId: number;
	    customerId: number;
	    birthday: number;
	    headUrl: string;
	    address: string;
	    email: string;
	    phone: string;
	    occupationCode: string;
	    occupationName: string;
	    workEnvCode: string;
	    workEnvName: string;
	    eyeUsageDistanceCode: string;
	    eyeUsageDistanceName: string;
	    medicalCardNumber: string;
	
	    static createFrom(source: any = {}) {
	        return new CreateCustomerRelativeReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.name = source["name"];
	        this.baseRelationId = source["baseRelationId"];
	        this.customerId = source["customerId"];
	        this.birthday = source["birthday"];
	        this.headUrl = source["headUrl"];
	        this.address = source["address"];
	        this.email = source["email"];
	        this.phone = source["phone"];
	        this.occupationCode = source["occupationCode"];
	        this.occupationName = source["occupationName"];
	        this.workEnvCode = source["workEnvCode"];
	        this.workEnvName = source["workEnvName"];
	        this.eyeUsageDistanceCode = source["eyeUsageDistanceCode"];
	        this.eyeUsageDistanceName = source["eyeUsageDistanceName"];
	        this.medicalCardNumber = source["medicalCardNumber"];
	    }
	}
	export class BatchCreateCustomerRelativeReq {
	    relatives: CreateCustomerRelativeReq[];
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new BatchCreateCustomerRelativeReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.relatives = this.convertValues(source["relatives"], CreateCustomerRelativeReq);
	        this.organId = source["organId"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class BrandBaseInfo {
	    id: number;
	    brandName: string;
	
	    static createFrom(source: any = {}) {
	        return new BrandBaseInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.brandName = source["brandName"];
	    }
	}
	export class BrandDropDownList {
	    list: BrandBaseInfo[];
	
	    static createFrom(source: any = {}) {
	        return new BrandDropDownList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], BrandBaseInfo);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class BrandDropDownListResp {
	    data: BrandDropDownList;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new BrandDropDownListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], BrandDropDownList);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class PupilPoints {
	    left: number[];
	    right: number[];
	
	    static createFrom(source: any = {}) {
	        return new PupilPoints(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.left = source["left"];
	        this.right = source["right"];
	    }
	}
	export class EyeAngles {
	    right_inner: number;
	    left_inner: number;
	    right_outer: number;
	    left_outer: number;
	
	    static createFrom(source: any = {}) {
	        return new EyeAngles(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.right_inner = source["right_inner"];
	        this.left_inner = source["left_inner"];
	        this.right_outer = source["right_outer"];
	        this.left_outer = source["left_outer"];
	    }
	}
	export class FaceWidths {
	    temple: number;
	    jaw: number;
	    mandible: number;
	
	    static createFrom(source: any = {}) {
	        return new FaceWidths(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.temple = source["temple"];
	        this.jaw = source["jaw"];
	        this.mandible = source["mandible"];
	    }
	}
	export class EyeDistances {
	    inner: number;
	    outer: number;
	
	    static createFrom(source: any = {}) {
	        return new EyeDistances(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.inner = source["inner"];
	        this.outer = source["outer"];
	    }
	}
	export class EyeDimensions {
	    width: number;
	    height: number;
	
	    static createFrom(source: any = {}) {
	        return new EyeDimensions(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.width = source["width"];
	        this.height = source["height"];
	    }
	}
	export class Measurements {
	    right_eye: EyeDimensions;
	    left_eye: EyeDimensions;
	    eye_distances: EyeDistances;
	    face_widths: FaceWidths;
	    eye_angles: EyeAngles;
	    golden_triangle_angle: number;
	    pupil_distance: number;
	
	    static createFrom(source: any = {}) {
	        return new Measurements(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.right_eye = this.convertValues(source["right_eye"], EyeDimensions);
	        this.left_eye = this.convertValues(source["left_eye"], EyeDimensions);
	        this.eye_distances = this.convertValues(source["eye_distances"], EyeDistances);
	        this.face_widths = this.convertValues(source["face_widths"], FaceWidths);
	        this.eye_angles = this.convertValues(source["eye_angles"], EyeAngles);
	        this.golden_triangle_angle = source["golden_triangle_angle"];
	        this.pupil_distance = source["pupil_distance"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CameraResponse {
	    code: number;
	    message: string;
	    face_detected: boolean;
	    measurements: Measurements;
	    pupil_points: PupilPoints;
	
	    static createFrom(source: any = {}) {
	        return new CameraResponse(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.message = source["message"];
	        this.face_detected = source["face_detected"];
	        this.measurements = this.convertValues(source["measurements"], Measurements);
	        this.pupil_points = this.convertValues(source["pupil_points"], PupilPoints);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CancelGlassesStorePurchaseOrderReqForApi {
	    orderId: number;
	
	    static createFrom(source: any = {}) {
	        return new CancelGlassesStorePurchaseOrderReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.orderId = source["orderId"];
	    }
	}
	export class CaptureResponse {
	    message: string;
	    code: number;
	    path: string;
	    depth_path: string;
	
	    static createFrom(source: any = {}) {
	        return new CaptureResponse(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.message = source["message"];
	        this.code = source["code"];
	        this.path = source["path"];
	        this.depth_path = source["depth_path"];
	    }
	}
	export class CaptureWithGlassResponse {
	    message: string;
	    code: number;
	    left_path: string;
	    right_path: string;
	    middle_path: string;
	
	    static createFrom(source: any = {}) {
	        return new CaptureWithGlassResponse(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.message = source["message"];
	        this.code = source["code"];
	        this.left_path = source["left_path"];
	        this.right_path = source["right_path"];
	        this.middle_path = source["middle_path"];
	    }
	}
	export class ChangeEmployeeStatusReqForApi {
	    id: number;
	    status: number;
	
	    static createFrom(source: any = {}) {
	        return new ChangeEmployeeStatusReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.status = source["status"];
	    }
	}
	export class OrganListReq {
	    organId: number;
	    startDate: number;
	    endDate: number;
	
	    static createFrom(source: any = {}) {
	        return new OrganListReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.organId = source["organId"];
	        this.startDate = source["startDate"];
	        this.endDate = source["endDate"];
	    }
	}
	export class ChecklistCodeReq {
	    Code: string;
	    Phone: string;
	    CustomerName: string;
	    CustomerId: number;
	    RelationId: number;
	    StartDate: string;
	    EndDate: string;
	    TimeType: number;
	    OrganQueries: OrganListReq[];
	    OrganId: number;
	    Page: number;
	    Size: number;
	    Ids: number[];
	    CheckListId: number;
	
	    static createFrom(source: any = {}) {
	        return new ChecklistCodeReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.Code = source["Code"];
	        this.Phone = source["Phone"];
	        this.CustomerName = source["CustomerName"];
	        this.CustomerId = source["CustomerId"];
	        this.RelationId = source["RelationId"];
	        this.StartDate = source["StartDate"];
	        this.EndDate = source["EndDate"];
	        this.TimeType = source["TimeType"];
	        this.OrganQueries = this.convertValues(source["OrganQueries"], OrganListReq);
	        this.OrganId = source["OrganId"];
	        this.Page = source["Page"];
	        this.Size = source["Size"];
	        this.Ids = source["Ids"];
	        this.CheckListId = source["CheckListId"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class DeviceOutCodeReq {
	    deviceId: number;
	    deviceSn: string;
	    outCode: string;
	    productsId: number;
	    isAuthentic: number;
	
	    static createFrom(source: any = {}) {
	        return new DeviceOutCodeReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.deviceId = source["deviceId"];
	        this.deviceSn = source["deviceSn"];
	        this.outCode = source["outCode"];
	        this.productsId = source["productsId"];
	        this.isAuthentic = source["isAuthentic"];
	    }
	}
	export class ProjectNameReq {
	    id: number;
	    projectName: string;
	    deviceList: DeviceOutCodeReq[];
	    count: number;
	    isCustomize: number;
	    regionId: number;
	
	    static createFrom(source: any = {}) {
	        return new ProjectNameReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.projectName = source["projectName"];
	        this.deviceList = this.convertValues(source["deviceList"], DeviceOutCodeReq);
	        this.count = source["count"];
	        this.isCustomize = source["isCustomize"];
	        this.regionId = source["regionId"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ChecklistDataForApi {
	    id: number;
	    createdAt: string;
	    updatedAt: string;
	    code: string;
	    customerId: number;
	    customerName: string;
	    customerPhone: string;
	    age: number;
	    sex: number;
	    birthday: number;
	    relationId: number;
	    relationName: string;
	    phone: string;
	    baseRelationId: number;
	    baseRelationName: string;
	    organId: number;
	    reportPdf: string;
	    status: number;
	    resultInfo: string;
	    advice: string;
	    projectId: number[];
	    projectList: ProjectNameReq[];
	    companyName: string;
	    origin: string;
	    occupation: string;
	    workEnvironment: string;
	    eyeDistance: string;
	    complaints: string;
	    medicalCardNumber: string;
	
	    static createFrom(source: any = {}) {
	        return new ChecklistDataForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.createdAt = source["createdAt"];
	        this.updatedAt = source["updatedAt"];
	        this.code = source["code"];
	        this.customerId = source["customerId"];
	        this.customerName = source["customerName"];
	        this.customerPhone = source["customerPhone"];
	        this.age = source["age"];
	        this.sex = source["sex"];
	        this.birthday = source["birthday"];
	        this.relationId = source["relationId"];
	        this.relationName = source["relationName"];
	        this.phone = source["phone"];
	        this.baseRelationId = source["baseRelationId"];
	        this.baseRelationName = source["baseRelationName"];
	        this.organId = source["organId"];
	        this.reportPdf = source["reportPdf"];
	        this.status = source["status"];
	        this.resultInfo = source["resultInfo"];
	        this.advice = source["advice"];
	        this.projectId = source["projectId"];
	        this.projectList = this.convertValues(source["projectList"], ProjectNameReq);
	        this.companyName = source["companyName"];
	        this.origin = source["origin"];
	        this.occupation = source["occupation"];
	        this.workEnvironment = source["workEnvironment"];
	        this.eyeDistance = source["eyeDistance"];
	        this.complaints = source["complaints"];
	        this.medicalCardNumber = source["medicalCardNumber"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ChecklistDataForApiResp {
	    code: number;
	    msg: string;
	    data: ChecklistDataForApi;
	
	    static createFrom(source: any = {}) {
	        return new ChecklistDataForApiResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], ChecklistDataForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class LabelDataReq {
	    id: number;
	    aiId: string;
	    dictLabel: string;
	
	    static createFrom(source: any = {}) {
	        return new LabelDataReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.aiId = source["aiId"];
	        this.dictLabel = source["dictLabel"];
	    }
	}
	export class ChecklistDiagnosisReq {
	    id: number;
	    name: string;
	    dataList: LabelDataReq[];
	
	    static createFrom(source: any = {}) {
	        return new ChecklistDiagnosisReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	        this.dataList = this.convertValues(source["dataList"], LabelDataReq);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ChecklistDiagnosisListReq {
	    checklistId: number;
	    dataType: string;
	    list: ChecklistDiagnosisReq[];
	
	    static createFrom(source: any = {}) {
	        return new ChecklistDiagnosisListReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.checklistId = source["checklistId"];
	        this.dataType = source["dataType"];
	        this.list = this.convertValues(source["list"], ChecklistDiagnosisReq);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	
	export class ChecklistInfoForApi {
	    id: number;
	    createdAt: string;
	    updatedAt: string;
	    code: string;
	    customerId: number;
	    customerName: string;
	    customerPhone: string;
	    age: number;
	    sex: number;
	    birthday: number;
	    relationId: number;
	    relationName: string;
	    phone: string;
	    baseRelationId: number;
	    baseRelationName: string;
	    organId: number;
	    reportPdf: string;
	    status: number;
	    resultInfo: string;
	    advice: string;
	    projectId: number[];
	    projectList: ProjectNameReq[];
	    companyName: string;
	    origin: string;
	    occupation: string;
	    workEnvironment: string;
	    eyeDistance: string;
	    complaints: string;
	    medicalCardNumber: string;
	
	    static createFrom(source: any = {}) {
	        return new ChecklistInfoForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.createdAt = source["createdAt"];
	        this.updatedAt = source["updatedAt"];
	        this.code = source["code"];
	        this.customerId = source["customerId"];
	        this.customerName = source["customerName"];
	        this.customerPhone = source["customerPhone"];
	        this.age = source["age"];
	        this.sex = source["sex"];
	        this.birthday = source["birthday"];
	        this.relationId = source["relationId"];
	        this.relationName = source["relationName"];
	        this.phone = source["phone"];
	        this.baseRelationId = source["baseRelationId"];
	        this.baseRelationName = source["baseRelationName"];
	        this.organId = source["organId"];
	        this.reportPdf = source["reportPdf"];
	        this.status = source["status"];
	        this.resultInfo = source["resultInfo"];
	        this.advice = source["advice"];
	        this.projectId = source["projectId"];
	        this.projectList = this.convertValues(source["projectList"], ProjectNameReq);
	        this.companyName = source["companyName"];
	        this.origin = source["origin"];
	        this.occupation = source["occupation"];
	        this.workEnvironment = source["workEnvironment"];
	        this.eyeDistance = source["eyeDistance"];
	        this.complaints = source["complaints"];
	        this.medicalCardNumber = source["medicalCardNumber"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ChecklistInfoForApiList {
	    list: ChecklistInfoForApi[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new ChecklistInfoForApiList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], ChecklistInfoForApi);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ChecklistInfoForApiResp {
	    data: ChecklistInfoForApiList;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new ChecklistInfoForApiResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], ChecklistInfoForApiList);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	
	export class CityBaseInfo {
	    id: number;
	    name: string;
	    pinyin: string;
	    code: string;
	
	    static createFrom(source: any = {}) {
	        return new CityBaseInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	        this.pinyin = source["pinyin"];
	        this.code = source["code"];
	    }
	}
	export class CodeReq {
	    Code: string;
	    phone: string;
	    customerName: string;
	    customerId: number;
	    relationId: number;
	    organId: number;
	    templateId: number;
	    startDate: string;
	    endDate: string;
	    timeType: number;
	    page: number;
	    size: number;
	
	    static createFrom(source: any = {}) {
	        return new CodeReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.Code = source["Code"];
	        this.phone = source["phone"];
	        this.customerName = source["customerName"];
	        this.customerId = source["customerId"];
	        this.relationId = source["relationId"];
	        this.organId = source["organId"];
	        this.templateId = source["templateId"];
	        this.startDate = source["startDate"];
	        this.endDate = source["endDate"];
	        this.timeType = source["timeType"];
	        this.page = source["page"];
	        this.size = source["size"];
	    }
	}
	export class CommonFileItem {
	    fileName: string;
	    fileUrl: string;
	    fileType: string;
	    fileExt: string;
	    fileSize: number;
	
	    static createFrom(source: any = {}) {
	        return new CommonFileItem(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.fileName = source["fileName"];
	        this.fileUrl = source["fileUrl"];
	        this.fileType = source["fileType"];
	        this.fileExt = source["fileExt"];
	        this.fileSize = source["fileSize"];
	    }
	}
	export class ConfirmGlassesStorePurchaseOrderReqForApi {
	    id: number;
	    status: number;
	
	    static createFrom(source: any = {}) {
	        return new ConfirmGlassesStorePurchaseOrderReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.status = source["status"];
	    }
	}
	export class ConfirmVisitRecordReqForApi {
	    id: number;
	    visitMethod: number;
	    visitResult: string;
	
	    static createFrom(source: any = {}) {
	        return new ConfirmVisitRecordReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.visitMethod = source["visitMethod"];
	        this.visitResult = source["visitResult"];
	    }
	}
	export class ControlVisitCycleSwitchReqForApi {
	    customerId: number;
	    reminderSwitch: number;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new ControlVisitCycleSwitchReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.customerId = source["customerId"];
	        this.reminderSwitch = source["reminderSwitch"];
	        this.organId = source["organId"];
	    }
	}
	export class CooperativeDoctorListInfo {
	    id: number;
	    doctorUsername: string;
	    doctorNickname: string;
	
	    static createFrom(source: any = {}) {
	        return new CooperativeDoctorListInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.doctorUsername = source["doctorUsername"];
	        this.doctorNickname = source["doctorNickname"];
	    }
	}
	export class CooperativeDoctorListAll {
	    list: CooperativeDoctorListInfo[];
	
	    static createFrom(source: any = {}) {
	        return new CooperativeDoctorListAll(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], CooperativeDoctorListInfo);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	
	export class CooperativeDoctorListResp {
	    data: CooperativeDoctorListAll;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new CooperativeDoctorListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], CooperativeDoctorListAll);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CountryInfo {
	    id: number;
	    code: string;
	    enName: string;
	    name: string;
	
	    static createFrom(source: any = {}) {
	        return new CountryInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.code = source["code"];
	        this.enName = source["enName"];
	        this.name = source["name"];
	    }
	}
	export class CountryInfoList {
	    countryList: CountryInfo[];
	
	    static createFrom(source: any = {}) {
	        return new CountryInfoList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.countryList = this.convertValues(source["countryList"], CountryInfo);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CountryInfoListResp {
	    code: number;
	    msg: string;
	    data: CountryInfoList;
	
	    static createFrom(source: any = {}) {
	        return new CountryInfoListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], CountryInfoList);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CreateChecklist {
	    id: number;
	    code: string;
	    projectIds: number[];
	
	    static createFrom(source: any = {}) {
	        return new CreateChecklist(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.code = source["code"];
	        this.projectIds = source["projectIds"];
	    }
	}
	export class CreateChecklistResp {
	    code: number;
	    msg: string;
	    data: CreateChecklist;
	
	    static createFrom(source: any = {}) {
	        return new CreateChecklistResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], CreateChecklist);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CreateCustomerForApi {
	    id: number;
	    customerName: string;
	    customerTel: string;
	    sex: number;
	    birthday: number;
	    nickname: string;
	    headUrl: string;
	    address: string;
	    customerSource: string;
	    accountSource: string;
	    remark: string;
	    vipIds: number;
	    tagIds: number[];
	    customerCode: string;
	    occupationCode: string;
	    occupationName: string;
	    workEnvCode: string;
	    workEnvName: string;
	    eyeUsageDistanceCode: string;
	    eyeUsageDistanceName: string;
	
	    static createFrom(source: any = {}) {
	        return new CreateCustomerForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.customerName = source["customerName"];
	        this.customerTel = source["customerTel"];
	        this.sex = source["sex"];
	        this.birthday = source["birthday"];
	        this.nickname = source["nickname"];
	        this.headUrl = source["headUrl"];
	        this.address = source["address"];
	        this.customerSource = source["customerSource"];
	        this.accountSource = source["accountSource"];
	        this.remark = source["remark"];
	        this.vipIds = source["vipIds"];
	        this.tagIds = source["tagIds"];
	        this.customerCode = source["customerCode"];
	        this.occupationCode = source["occupationCode"];
	        this.occupationName = source["occupationName"];
	        this.workEnvCode = source["workEnvCode"];
	        this.workEnvName = source["workEnvName"];
	        this.eyeUsageDistanceCode = source["eyeUsageDistanceCode"];
	        this.eyeUsageDistanceName = source["eyeUsageDistanceName"];
	    }
	}
	
	export class CustomerForApi {
	    id: number;
	    createdTime: number;
	    updatedTime: number;
	    customerName: string;
	    customerTel: string;
	    sex: number;
	    birthday: number;
	    age: number;
	    nickname: string;
	    headUrl: string;
	    wxOpenid: string;
	    address: string;
	    reminderSwitch: number;
	    visitCycleDays: number;
	    nextVisitTime: number;
	    customerSource: string;
	    accountSource: string;
	    remark: string;
	    vipName: string;
	    tags: string[];
	    assets: Assets;
	    customerCode: string;
	    occupationCode: string;
	    occupationName: string;
	    workEnvCode: string;
	    workEnvName: string;
	    eyeUsageDistanceCode: string;
	    eyeUsageDistanceName: string;
	    selfRelativeId: number;
	    selfRelativeName: string;
	    phone: string;
	    baseRelativeId: number;
	    baseRelativeName: string;
	    medicalCardNumber: string;
	
	    static createFrom(source: any = {}) {
	        return new CustomerForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.createdTime = source["createdTime"];
	        this.updatedTime = source["updatedTime"];
	        this.customerName = source["customerName"];
	        this.customerTel = source["customerTel"];
	        this.sex = source["sex"];
	        this.birthday = source["birthday"];
	        this.age = source["age"];
	        this.nickname = source["nickname"];
	        this.headUrl = source["headUrl"];
	        this.wxOpenid = source["wxOpenid"];
	        this.address = source["address"];
	        this.reminderSwitch = source["reminderSwitch"];
	        this.visitCycleDays = source["visitCycleDays"];
	        this.nextVisitTime = source["nextVisitTime"];
	        this.customerSource = source["customerSource"];
	        this.accountSource = source["accountSource"];
	        this.remark = source["remark"];
	        this.vipName = source["vipName"];
	        this.tags = source["tags"];
	        this.assets = this.convertValues(source["assets"], Assets);
	        this.customerCode = source["customerCode"];
	        this.occupationCode = source["occupationCode"];
	        this.occupationName = source["occupationName"];
	        this.workEnvCode = source["workEnvCode"];
	        this.workEnvName = source["workEnvName"];
	        this.eyeUsageDistanceCode = source["eyeUsageDistanceCode"];
	        this.eyeUsageDistanceName = source["eyeUsageDistanceName"];
	        this.selfRelativeId = source["selfRelativeId"];
	        this.selfRelativeName = source["selfRelativeName"];
	        this.phone = source["phone"];
	        this.baseRelativeId = source["baseRelativeId"];
	        this.baseRelativeName = source["baseRelativeName"];
	        this.medicalCardNumber = source["medicalCardNumber"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CreateCustomerRespForApi {
	    customer: CustomerForApi;
	
	    static createFrom(source: any = {}) {
	        return new CreateCustomerRespForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.customer = this.convertValues(source["customer"], CustomerForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CreateCustomerResp {
	    code: number;
	    msg: string;
	    data: CreateCustomerRespForApi;
	
	    static createFrom(source: any = {}) {
	        return new CreateCustomerResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], CreateCustomerRespForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	
	export class GlassesStorePurchaseOrderItemForApi {
	    id: number;
	    goodsId: number;
	    count: number;
	    priceAtOrder: number;
	    discount: number;
	    amount: number;
	    goodsTitle: string;
	    goodsImgAtOrder: string;
	    brandName: string;
	    categoryName: string;
	    typeName: string;
	    goodsCode: string;
	    providerId: number;
	    orderId: number;
	    inventoryCount: number;
	    goodsSpecId: number;
	    goodsSpecName: string;
	    spelling: string;
	    description: string;
	
	    static createFrom(source: any = {}) {
	        return new GlassesStorePurchaseOrderItemForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.goodsId = source["goodsId"];
	        this.count = source["count"];
	        this.priceAtOrder = source["priceAtOrder"];
	        this.discount = source["discount"];
	        this.amount = source["amount"];
	        this.goodsTitle = source["goodsTitle"];
	        this.goodsImgAtOrder = source["goodsImgAtOrder"];
	        this.brandName = source["brandName"];
	        this.categoryName = source["categoryName"];
	        this.typeName = source["typeName"];
	        this.goodsCode = source["goodsCode"];
	        this.providerId = source["providerId"];
	        this.orderId = source["orderId"];
	        this.inventoryCount = source["inventoryCount"];
	        this.goodsSpecId = source["goodsSpecId"];
	        this.goodsSpecName = source["goodsSpecName"];
	        this.spelling = source["spelling"];
	        this.description = source["description"];
	    }
	}
	export class GlassesStorePurchaseOrderForApi {
	    id: number;
	    providerId: number;
	    organId: number;
	    totalAmount: number;
	    paidAmount: number;
	    discount: number;
	    quantity: number;
	    status: number;
	    remark: string;
	    providerName: string;
	    providerPhone: string;
	    createdAt: number;
	    updatedAt: number;
	    orderCode: string;
	    items: GlassesStorePurchaseOrderItemForApi[];
	    createUserId: number;
	    createUserName: string;
	    inventoryCount: number;
	    businessUserId: number;
	    businessUserName: string;
	    businessTime: number;
	
	    static createFrom(source: any = {}) {
	        return new GlassesStorePurchaseOrderForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.providerId = source["providerId"];
	        this.organId = source["organId"];
	        this.totalAmount = source["totalAmount"];
	        this.paidAmount = source["paidAmount"];
	        this.discount = source["discount"];
	        this.quantity = source["quantity"];
	        this.status = source["status"];
	        this.remark = source["remark"];
	        this.providerName = source["providerName"];
	        this.providerPhone = source["providerPhone"];
	        this.createdAt = source["createdAt"];
	        this.updatedAt = source["updatedAt"];
	        this.orderCode = source["orderCode"];
	        this.items = this.convertValues(source["items"], GlassesStorePurchaseOrderItemForApi);
	        this.createUserId = source["createUserId"];
	        this.createUserName = source["createUserName"];
	        this.inventoryCount = source["inventoryCount"];
	        this.businessUserId = source["businessUserId"];
	        this.businessUserName = source["businessUserName"];
	        this.businessTime = source["businessTime"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CreateGlassesStorePurchaseOrderReqForApi {
	    glassesStorePurchaseOrder: GlassesStorePurchaseOrderForApi;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new CreateGlassesStorePurchaseOrderReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.glassesStorePurchaseOrder = this.convertValues(source["glassesStorePurchaseOrder"], GlassesStorePurchaseOrderForApi);
	        this.organId = source["organId"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CreateGlassesStorePurchaseOrderRespForApi {
	    glassesStorePurchaseOrder: GlassesStorePurchaseOrderForApi;
	
	    static createFrom(source: any = {}) {
	        return new CreateGlassesStorePurchaseOrderRespForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.glassesStorePurchaseOrder = this.convertValues(source["glassesStorePurchaseOrder"], GlassesStorePurchaseOrderForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CreateGlassesStorePurchaseOrderRespForApiResp {
	    data: CreateGlassesStorePurchaseOrderRespForApi;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new CreateGlassesStorePurchaseOrderRespForApiResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], CreateGlassesStorePurchaseOrderRespForApi);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class OrderItems {
	    count: number;
	    goodId: number;
	    goodsTitle: string;
	    priceAtOrder: number;
	    discount: number;
	    amount: number;
	    ignoreStock: number;
	    codes: string[];
	    eyeType: number;
	    goodsId: number;
	    goodsImgAtOrder: string;
	    brandName: string;
	    categoryName: string;
	    typeName: string;
	    goodsCode: string;
	    goodsSpecId: number;
	    goodsSpecName: string;
	    spelling: string;
	    description: string;
	    vipDiscountRate: number;
	    subItemDiscount: number;
	
	    static createFrom(source: any = {}) {
	        return new OrderItems(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.count = source["count"];
	        this.goodId = source["goodId"];
	        this.goodsTitle = source["goodsTitle"];
	        this.priceAtOrder = source["priceAtOrder"];
	        this.discount = source["discount"];
	        this.amount = source["amount"];
	        this.ignoreStock = source["ignoreStock"];
	        this.codes = source["codes"];
	        this.eyeType = source["eyeType"];
	        this.goodsId = source["goodsId"];
	        this.goodsImgAtOrder = source["goodsImgAtOrder"];
	        this.brandName = source["brandName"];
	        this.categoryName = source["categoryName"];
	        this.typeName = source["typeName"];
	        this.goodsCode = source["goodsCode"];
	        this.goodsSpecId = source["goodsSpecId"];
	        this.goodsSpecName = source["goodsSpecName"];
	        this.spelling = source["spelling"];
	        this.description = source["description"];
	        this.vipDiscountRate = source["vipDiscountRate"];
	        this.subItemDiscount = source["subItemDiscount"];
	    }
	}
	export class CreateGlassesStoreUnfinishedOrderReqForApi {
	    orderItems: OrderItems[];
	    customerId: number;
	    discountCouponId: number;
	    totalAmount: number;
	    paidAmount: number;
	    discount: number;
	    quantity: number;
	    remark: string;
	    isProcess: number;
	    checkListId: number;
	    checkCode: string;
	    businessUserId: number;
	    businessUserName: string;
	    businessTime: number;
	    vipDiscount: number;
	    subTotalDiscount: number;
	    receivableAmount: number;
	    totalDiscount: number;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new CreateGlassesStoreUnfinishedOrderReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.orderItems = this.convertValues(source["orderItems"], OrderItems);
	        this.customerId = source["customerId"];
	        this.discountCouponId = source["discountCouponId"];
	        this.totalAmount = source["totalAmount"];
	        this.paidAmount = source["paidAmount"];
	        this.discount = source["discount"];
	        this.quantity = source["quantity"];
	        this.remark = source["remark"];
	        this.isProcess = source["isProcess"];
	        this.checkListId = source["checkListId"];
	        this.checkCode = source["checkCode"];
	        this.businessUserId = source["businessUserId"];
	        this.businessUserName = source["businessUserName"];
	        this.businessTime = source["businessTime"];
	        this.vipDiscount = source["vipDiscount"];
	        this.subTotalDiscount = source["subTotalDiscount"];
	        this.receivableAmount = source["receivableAmount"];
	        this.totalDiscount = source["totalDiscount"];
	        this.organId = source["organId"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CreateMqttAuthCodeReq {
	    authExpireTime: number;
	    brandName: string;
	    categoryName: string;
	    deviceSn: string;
	    doctorNickname: string;
	    doctorUsername: string;
	    outCode: string;
	    typeName: string;
	
	    static createFrom(source: any = {}) {
	        return new CreateMqttAuthCodeReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.authExpireTime = source["authExpireTime"];
	        this.brandName = source["brandName"];
	        this.categoryName = source["categoryName"];
	        this.deviceSn = source["deviceSn"];
	        this.doctorNickname = source["doctorNickname"];
	        this.doctorUsername = source["doctorUsername"];
	        this.outCode = source["outCode"];
	        this.typeName = source["typeName"];
	    }
	}
	export class CreateOrderReqForApi {
	    orderItems: OrderItems[];
	    customerId: number;
	    totalAmount: number;
	    paidAmount: number;
	    discount: number;
	    quantity: number;
	    remark: string;
	    isProcess: number;
	    checkListId: number;
	    checkCode: string;
	    businessUserId: number;
	    businessUserName: string;
	    businessTime: number;
	    vipDiscount: number;
	    subTotalDiscount: number;
	    receivableAmount: number;
	    totalDiscount: number;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new CreateOrderReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.orderItems = this.convertValues(source["orderItems"], OrderItems);
	        this.customerId = source["customerId"];
	        this.totalAmount = source["totalAmount"];
	        this.paidAmount = source["paidAmount"];
	        this.discount = source["discount"];
	        this.quantity = source["quantity"];
	        this.remark = source["remark"];
	        this.isProcess = source["isProcess"];
	        this.checkListId = source["checkListId"];
	        this.checkCode = source["checkCode"];
	        this.businessUserId = source["businessUserId"];
	        this.businessUserName = source["businessUserName"];
	        this.businessTime = source["businessTime"];
	        this.vipDiscount = source["vipDiscount"];
	        this.subTotalDiscount = source["subTotalDiscount"];
	        this.receivableAmount = source["receivableAmount"];
	        this.totalDiscount = source["totalDiscount"];
	        this.organId = source["organId"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class PaymentConfig {
	    platform: string;
	    paymentMethodID: number;
	    icon: string;
	    isEnabled: boolean;
	
	    static createFrom(source: any = {}) {
	        return new PaymentConfig(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.platform = source["platform"];
	        this.paymentMethodID = source["paymentMethodID"];
	        this.icon = source["icon"];
	        this.isEnabled = source["isEnabled"];
	    }
	}
	export class CreateOrderResqForApi {
	    id: number;
	    orderCode: string;
	    totalAmount: number;
	    paidAmount: number;
	    canPay: boolean;
	    paymentOptions: PaymentConfig[];
	
	    static createFrom(source: any = {}) {
	        return new CreateOrderResqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.orderCode = source["orderCode"];
	        this.totalAmount = source["totalAmount"];
	        this.paidAmount = source["paidAmount"];
	        this.canPay = source["canPay"];
	        this.paymentOptions = this.convertValues(source["paymentOptions"], PaymentConfig);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CreateOrderResqForApiResp {
	    data: CreateOrderResqForApi;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new CreateOrderResqForApiResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], CreateOrderResqForApi);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CreateOrganApiReq {
	    sourceId: number;
	    departmentId: number;
	    positionId: number;
	    isDistribution: boolean;
	    organId: number;
	    domValue: string;
	
	    static createFrom(source: any = {}) {
	        return new CreateOrganApiReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.sourceId = source["sourceId"];
	        this.departmentId = source["departmentId"];
	        this.positionId = source["positionId"];
	        this.isDistribution = source["isDistribution"];
	        this.organId = source["organId"];
	        this.domValue = source["domValue"];
	    }
	}
	export class CreateOrganMenuReq {
	    sourceIds: number[];
	    departmentId: number;
	    positionId: number;
	    organId: number;
	    domValue: string;
	
	    static createFrom(source: any = {}) {
	        return new CreateOrganMenuReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.sourceIds = source["sourceIds"];
	        this.departmentId = source["departmentId"];
	        this.positionId = source["positionId"];
	        this.organId = source["organId"];
	        this.domValue = source["domValue"];
	    }
	}
	export class CreateOrganizeDepartmentReqForApi {
	    parentId: number;
	    departmentName: string;
	    remark: string;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new CreateOrganizeDepartmentReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.parentId = source["parentId"];
	        this.departmentName = source["departmentName"];
	        this.remark = source["remark"];
	        this.organId = source["organId"];
	    }
	}
	export class DepartmentPositionItem {
	    departmentId: number;
	    departmentName: string;
	    positionId: number;
	    positionName: string;
	
	    static createFrom(source: any = {}) {
	        return new DepartmentPositionItem(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.departmentId = source["departmentId"];
	        this.departmentName = source["departmentName"];
	        this.positionId = source["positionId"];
	        this.positionName = source["positionName"];
	    }
	}
	export class CreateOrganizeEmployeeReq {
	    certificateUrl: string;
	    idCard: string;
	    name: string;
	    sex: number;
	    phoneNumber: string;
	    departmentPositionList: DepartmentPositionItem[];
	    headUrl: string;
	    userName: string;
	    organId: number;
	    domValue: string;
	    organClassificationId: number;
	
	    static createFrom(source: any = {}) {
	        return new CreateOrganizeEmployeeReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.certificateUrl = source["certificateUrl"];
	        this.idCard = source["idCard"];
	        this.name = source["name"];
	        this.sex = source["sex"];
	        this.phoneNumber = source["phoneNumber"];
	        this.departmentPositionList = this.convertValues(source["departmentPositionList"], DepartmentPositionItem);
	        this.headUrl = source["headUrl"];
	        this.userName = source["userName"];
	        this.organId = source["organId"];
	        this.domValue = source["domValue"];
	        this.organClassificationId = source["organClassificationId"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CreatePositionForDepartmentReqForApi {
	    departmentId: number;
	    departmentName: string;
	    positionId: number;
	    positionName: string;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new CreatePositionForDepartmentReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.departmentId = source["departmentId"];
	        this.departmentName = source["departmentName"];
	        this.positionId = source["positionId"];
	        this.positionName = source["positionName"];
	        this.organId = source["organId"];
	    }
	}
	export class CreatePreferenceReq {
	    word: string;
	    organId: number;
	    typeName: string;
	
	    static createFrom(source: any = {}) {
	        return new CreatePreferenceReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.word = source["word"];
	        this.organId = source["organId"];
	        this.typeName = source["typeName"];
	    }
	}
	export class CreateReturnOrderItemReq {
	    oldOrderId: number;
	    oldOrderCode: string;
	    oldOrderItemId: number;
	    customerId: number;
	    quantity: number;
	    returnAmount: number;
	    returnType: number;
	    remark: string;
	    oldCodes: string[];
	    newOrderItem: OrderItems;
	
	    static createFrom(source: any = {}) {
	        return new CreateReturnOrderItemReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.oldOrderId = source["oldOrderId"];
	        this.oldOrderCode = source["oldOrderCode"];
	        this.oldOrderItemId = source["oldOrderItemId"];
	        this.customerId = source["customerId"];
	        this.quantity = source["quantity"];
	        this.returnAmount = source["returnAmount"];
	        this.returnType = source["returnType"];
	        this.remark = source["remark"];
	        this.oldCodes = source["oldCodes"];
	        this.newOrderItem = this.convertValues(source["newOrderItem"], OrderItems);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CreateReturnOrderReqForApi {
	    item: CreateReturnOrderItemReq;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new CreateReturnOrderReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.item = this.convertValues(source["item"], CreateReturnOrderItemReq);
	        this.organId = source["organId"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class StatementsForApi {
	    id: number;
	    orderId: number;
	    amount: number;
	    bType: number;
	    orderType: number;
	    description: string;
	    organId: number;
	    createUserId: number;
	    createName: string;
	    createdAt: number;
	    orderCode: string;
	    businessUserId: number;
	    businessUserName: string;
	    businessTime: number;
	    actualAmount: number;
	
	    static createFrom(source: any = {}) {
	        return new StatementsForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.orderId = source["orderId"];
	        this.amount = source["amount"];
	        this.bType = source["bType"];
	        this.orderType = source["orderType"];
	        this.description = source["description"];
	        this.organId = source["organId"];
	        this.createUserId = source["createUserId"];
	        this.createName = source["createName"];
	        this.createdAt = source["createdAt"];
	        this.orderCode = source["orderCode"];
	        this.businessUserId = source["businessUserId"];
	        this.businessUserName = source["businessUserName"];
	        this.businessTime = source["businessTime"];
	        this.actualAmount = source["actualAmount"];
	    }
	}
	export class CreateStatementsReqForApi {
	    statement: StatementsForApi;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new CreateStatementsReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.statement = this.convertValues(source["statement"], StatementsForApi);
	        this.organId = source["organId"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CreateStatementsRespForApi {
	    statement: StatementsForApi;
	
	    static createFrom(source: any = {}) {
	        return new CreateStatementsRespForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.statement = this.convertValues(source["statement"], StatementsForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CreateStatementsRespForApiResp {
	    code: number;
	    msg: string;
	    data: CreateStatementsRespForApi;
	
	    static createFrom(source: any = {}) {
	        return new CreateStatementsRespForApiResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], CreateStatementsRespForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CreateVisitRecordReqForApi {
	    customerId: number;
	    estimatedVisitTime: number;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new CreateVisitRecordReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.customerId = source["customerId"];
	        this.estimatedVisitTime = source["estimatedVisitTime"];
	        this.organId = source["organId"];
	    }
	}
	export class CustomCheckOrderQrCode {
	    qrCodeUrl: string;
	    errMsg: string;
	    errCode: string;
	
	    static createFrom(source: any = {}) {
	        return new CustomCheckOrderQrCode(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.qrCodeUrl = source["qrCodeUrl"];
	        this.errMsg = source["errMsg"];
	        this.errCode = source["errCode"];
	    }
	}
	export class CustomCheckOrderQrCodeResp {
	    data: CustomCheckOrderQrCode;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new CustomCheckOrderQrCodeResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], CustomCheckOrderQrCode);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CustomCheckQrCodeSettingData {
	    id: number;
	    remark: string;
	    checkLogo: string;
	    checkTitle: string;
	    isDefault: number;
	    organizeId: number;
	
	    static createFrom(source: any = {}) {
	        return new CustomCheckQrCodeSettingData(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.remark = source["remark"];
	        this.checkLogo = source["checkLogo"];
	        this.checkTitle = source["checkTitle"];
	        this.isDefault = source["isDefault"];
	        this.organizeId = source["organizeId"];
	    }
	}
	export class CustomCheckQrCodeSettingId {
	    id: number;
	    organizeId: number;
	
	    static createFrom(source: any = {}) {
	        return new CustomCheckQrCodeSettingId(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.organizeId = source["organizeId"];
	    }
	}
	export class CustomCheckQrCodeSettingInfo {
	    id: number;
	    checkLogo: string;
	    checkTitle: string;
	    remark: string;
	    isDefault: number;
	
	    static createFrom(source: any = {}) {
	        return new CustomCheckQrCodeSettingInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.checkLogo = source["checkLogo"];
	        this.checkTitle = source["checkTitle"];
	        this.remark = source["remark"];
	        this.isDefault = source["isDefault"];
	    }
	}
	export class CustomCheckQrCodeSettingInfoResp {
	    code: number;
	    msg: string;
	    data: CustomCheckQrCodeSettingData;
	
	    static createFrom(source: any = {}) {
	        return new CustomCheckQrCodeSettingInfoResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], CustomCheckQrCodeSettingData);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CustomCheckQrCodeSettingList {
	    list: CustomCheckQrCodeSettingInfo[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new CustomCheckQrCodeSettingList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], CustomCheckQrCodeSettingInfo);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CustomCheckQrCodeSettingListResp {
	    code: number;
	    msg: string;
	    data: CustomCheckQrCodeSettingList;
	
	    static createFrom(source: any = {}) {
	        return new CustomCheckQrCodeSettingListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], CustomCheckQrCodeSettingList);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CustomCheckQrCodeSettingParams {
	    Page: number;
	    PageSize: number;
	    OrganizeId: number;
	
	    static createFrom(source: any = {}) {
	        return new CustomCheckQrCodeSettingParams(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.Page = source["Page"];
	        this.PageSize = source["PageSize"];
	        this.OrganizeId = source["OrganizeId"];
	    }
	}
	export class CustomQueryId {
	    Id: number;
	    OrganizeId: number;
	
	    static createFrom(source: any = {}) {
	        return new CustomQueryId(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.Id = source["Id"];
	        this.OrganizeId = source["OrganizeId"];
	    }
	}
	export class CustomerCases {
	    customerId: number;
	    relationId: number;
	    name: string;
	    sex: number;
	    age: number;
	    baseRelationName: string;
	    baseRelationId: number;
	    caseNum: number;
	    headerUrl: string;
	    address: string;
	    email: string;
	    phone: string;
	    occupationCode: string;
	    occupationName: string;
	    workEnvCode: string;
	    workEnvName: string;
	    eyeUsageDistanceCode: string;
	    eyeUsageDistanceName: string;
	    medicalCardNumber: string;
	
	    static createFrom(source: any = {}) {
	        return new CustomerCases(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.customerId = source["customerId"];
	        this.relationId = source["relationId"];
	        this.name = source["name"];
	        this.sex = source["sex"];
	        this.age = source["age"];
	        this.baseRelationName = source["baseRelationName"];
	        this.baseRelationId = source["baseRelationId"];
	        this.caseNum = source["caseNum"];
	        this.headerUrl = source["headerUrl"];
	        this.address = source["address"];
	        this.email = source["email"];
	        this.phone = source["phone"];
	        this.occupationCode = source["occupationCode"];
	        this.occupationName = source["occupationName"];
	        this.workEnvCode = source["workEnvCode"];
	        this.workEnvName = source["workEnvName"];
	        this.eyeUsageDistanceCode = source["eyeUsageDistanceCode"];
	        this.eyeUsageDistanceName = source["eyeUsageDistanceName"];
	        this.medicalCardNumber = source["medicalCardNumber"];
	    }
	}
	export class CustomerChecklistRequest {
	    id: number;
	    createdAt: string;
	    updatedAt: string;
	    code: string;
	    headUrl: string;
	    customerId: number;
	    customerName: string;
	    customerPhone: string;
	    relationId: number;
	    relationName: string;
	    sex: number;
	    paidAmount: number;
	    phone: string;
	    projectList: ProjectNameReq[];
	
	    static createFrom(source: any = {}) {
	        return new CustomerChecklistRequest(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.createdAt = source["createdAt"];
	        this.updatedAt = source["updatedAt"];
	        this.code = source["code"];
	        this.headUrl = source["headUrl"];
	        this.customerId = source["customerId"];
	        this.customerName = source["customerName"];
	        this.customerPhone = source["customerPhone"];
	        this.relationId = source["relationId"];
	        this.relationName = source["relationName"];
	        this.sex = source["sex"];
	        this.paidAmount = source["paidAmount"];
	        this.phone = source["phone"];
	        this.projectList = this.convertValues(source["projectList"], ProjectNameReq);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CustomerChecklistRequestList {
	    list: CustomerChecklistRequest[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new CustomerChecklistRequestList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], CustomerChecklistRequest);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CustomerChecklistRequestResp {
	    code: number;
	    msg: string;
	    data: CustomerChecklistRequestList;
	
	    static createFrom(source: any = {}) {
	        return new CustomerChecklistRequestResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], CustomerChecklistRequestList);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	
	export class CustomerListReq {
	    page: number;
	    pageSize: number;
	    customerName: string;
	    customerTel: string;
	    sex: number;
	    ageStart: number;
	    ageEnd: number;
	    createAtStart: number;
	    createAtEnd: number;
	    vipIds: number[];
	    customerCode: string;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new CustomerListReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.page = source["page"];
	        this.pageSize = source["pageSize"];
	        this.customerName = source["customerName"];
	        this.customerTel = source["customerTel"];
	        this.sex = source["sex"];
	        this.ageStart = source["ageStart"];
	        this.ageEnd = source["ageEnd"];
	        this.createAtStart = source["createAtStart"];
	        this.createAtEnd = source["createAtEnd"];
	        this.vipIds = source["vipIds"];
	        this.customerCode = source["customerCode"];
	        this.organId = source["organId"];
	    }
	}
	export class TreeCustomerInfo {
	    id: number;
	    createdTime: number;
	    updatedTime: number;
	    customerName: string;
	    customerTel: string;
	    sex: number;
	    birthday: number;
	    age: number;
	    nickname: string;
	    headUrl: string;
	    wxOpenid: string;
	    address: string;
	    reminderSwitch: number;
	    visitCycleDays: number;
	    nextVisitTime: number;
	    customerSource: string;
	    accountSource: string;
	    remark: string;
	    vipName: string;
	    tags: string[];
	    assets: Assets;
	    customerCode: string;
	    occupationCode: string;
	    occupationName: string;
	    workEnvCode: string;
	    workEnvName: string;
	    eyeUsageDistanceCode: string;
	    eyeUsageDistanceName: string;
	    selfRelativeId: number;
	    customers: CustomerCases[];
	    trainingCount: number;
	
	    static createFrom(source: any = {}) {
	        return new TreeCustomerInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.createdTime = source["createdTime"];
	        this.updatedTime = source["updatedTime"];
	        this.customerName = source["customerName"];
	        this.customerTel = source["customerTel"];
	        this.sex = source["sex"];
	        this.birthday = source["birthday"];
	        this.age = source["age"];
	        this.nickname = source["nickname"];
	        this.headUrl = source["headUrl"];
	        this.wxOpenid = source["wxOpenid"];
	        this.address = source["address"];
	        this.reminderSwitch = source["reminderSwitch"];
	        this.visitCycleDays = source["visitCycleDays"];
	        this.nextVisitTime = source["nextVisitTime"];
	        this.customerSource = source["customerSource"];
	        this.accountSource = source["accountSource"];
	        this.remark = source["remark"];
	        this.vipName = source["vipName"];
	        this.tags = source["tags"];
	        this.assets = this.convertValues(source["assets"], Assets);
	        this.customerCode = source["customerCode"];
	        this.occupationCode = source["occupationCode"];
	        this.occupationName = source["occupationName"];
	        this.workEnvCode = source["workEnvCode"];
	        this.workEnvName = source["workEnvName"];
	        this.eyeUsageDistanceCode = source["eyeUsageDistanceCode"];
	        this.eyeUsageDistanceName = source["eyeUsageDistanceName"];
	        this.selfRelativeId = source["selfRelativeId"];
	        this.customers = this.convertValues(source["customers"], CustomerCases);
	        this.trainingCount = source["trainingCount"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetTreeCustomerListResp {
	    total: number;
	    customers: TreeCustomerInfo[];
	
	    static createFrom(source: any = {}) {
	        return new GetTreeCustomerListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.total = source["total"];
	        this.customers = this.convertValues(source["customers"], TreeCustomerInfo);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CustomerListResp {
	    code: number;
	    msg: string;
	    data: GetTreeCustomerListResp;
	
	    static createFrom(source: any = {}) {
	        return new CustomerListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], GetTreeCustomerListResp);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CustomerRelativesForListRespForApi {
	    id: number;
	    name: string;
	    sex: number;
	    baseRelationId: number;
	    customerId: number;
	    customerName: string;
	    customerTel: string;
	    organId: number;
	    birthday: number;
	    age: number;
	    baseRelationName: string;
	    ageValid: boolean;
	    phone: string;
	    occupationCode: string;
	    occupationName: string;
	    workEnvCode: string;
	    workEnvName: string;
	    eyeUsageDistanceCode: string;
	    eyeUsageDistanceName: string;
	    medicalCardNumber: string;
	
	    static createFrom(source: any = {}) {
	        return new CustomerRelativesForListRespForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	        this.sex = source["sex"];
	        this.baseRelationId = source["baseRelationId"];
	        this.customerId = source["customerId"];
	        this.customerName = source["customerName"];
	        this.customerTel = source["customerTel"];
	        this.organId = source["organId"];
	        this.birthday = source["birthday"];
	        this.age = source["age"];
	        this.baseRelationName = source["baseRelationName"];
	        this.ageValid = source["ageValid"];
	        this.phone = source["phone"];
	        this.occupationCode = source["occupationCode"];
	        this.occupationName = source["occupationName"];
	        this.workEnvCode = source["workEnvCode"];
	        this.workEnvName = source["workEnvName"];
	        this.eyeUsageDistanceCode = source["eyeUsageDistanceCode"];
	        this.eyeUsageDistanceName = source["eyeUsageDistanceName"];
	        this.medicalCardNumber = source["medicalCardNumber"];
	    }
	}
	export class CustomerRelativesForList {
	    list: CustomerRelativesForListRespForApi[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new CustomerRelativesForList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], CustomerRelativesForListRespForApi);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class CustomerRelativesForListResp {
	    code: number;
	    msg: string;
	    data: CustomerRelativesForList;
	
	    static createFrom(source: any = {}) {
	        return new CustomerRelativesForListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], CustomerRelativesForList);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	
	export class DataBridgeInfo {
	    id: number;
	    srcOutCode: string;
	    srcDeviceSn: string;
	    distOutCode: string;
	    distDeviceSn: string;
	    isOk: number;
	
	    static createFrom(source: any = {}) {
	        return new DataBridgeInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.srcOutCode = source["srcOutCode"];
	        this.srcDeviceSn = source["srcDeviceSn"];
	        this.distOutCode = source["distOutCode"];
	        this.distDeviceSn = source["distDeviceSn"];
	        this.isOk = source["isOk"];
	    }
	}
	export class DataBridgeList {
	    list: DataBridgeInfo[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new DataBridgeList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], DataBridgeInfo);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class DateBridgeBindReq {
	    id: number;
	    distDeviceSn: string;
	    distOutCode: string;
	    isOk: number;
	    messageTypes: string;
	    srcDeviceSn: string;
	    srcOutCode: string;
	
	    static createFrom(source: any = {}) {
	        return new DateBridgeBindReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.distDeviceSn = source["distDeviceSn"];
	        this.distOutCode = source["distOutCode"];
	        this.isOk = source["isOk"];
	        this.messageTypes = source["messageTypes"];
	        this.srcDeviceSn = source["srcDeviceSn"];
	        this.srcOutCode = source["srcOutCode"];
	    }
	}
	export class DeleteChecklistReq {
	    id: number;
	
	    static createFrom(source: any = {}) {
	        return new DeleteChecklistReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	    }
	}
	export class DeleteCustomerByIdReqForApi {
	    customerId: number;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new DeleteCustomerByIdReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.customerId = source["customerId"];
	        this.organId = source["organId"];
	    }
	}
	export class DeleteGlassesStorePurchaseOrderReqForApi {
	    id: number;
	
	    static createFrom(source: any = {}) {
	        return new DeleteGlassesStorePurchaseOrderReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	    }
	}
	export class DeleteOrderReq {
	    id: number;
	
	    static createFrom(source: any = {}) {
	        return new DeleteOrderReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	    }
	}
	export class DeleteOrganizeDepartmentByIdReqForApi {
	    id: number;
	
	    static createFrom(source: any = {}) {
	        return new DeleteOrganizeDepartmentByIdReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	    }
	}
	export class DeleteOrganizeEmployeeByIdReqForApi {
	    id: number;
	
	    static createFrom(source: any = {}) {
	        return new DeleteOrganizeEmployeeByIdReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	    }
	}
	export class DeletePositionForDepartmentReqForApi {
	    departmentId: number;
	    positionId: number;
	
	    static createFrom(source: any = {}) {
	        return new DeletePositionForDepartmentReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.departmentId = source["departmentId"];
	        this.positionId = source["positionId"];
	    }
	}
	export class DeleteProviderToOpticianReqForApi {
	    id: number;
	
	    static createFrom(source: any = {}) {
	        return new DeleteProviderToOpticianReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	    }
	}
	export class DeleteStatementsReqForApi {
	    ids: number[];
	
	    static createFrom(source: any = {}) {
	        return new DeleteStatementsReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.ids = source["ids"];
	    }
	}
	export class DeleteVisitRecordReq {
	    id: number;
	
	    static createFrom(source: any = {}) {
	        return new DeleteVisitRecordReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	    }
	}
	export class DepartmentPathNode {
	    id: number;
	    name: string;
	
	    static createFrom(source: any = {}) {
	        return new DepartmentPathNode(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	    }
	}
	
	export class EmployeeDepartmentPositionInfo {
	    departmentId: number;
	    departmentName: string;
	    positionId: number;
	    positionName: string;
	    departmentPath: DepartmentPathNode[];
	
	    static createFrom(source: any = {}) {
	        return new EmployeeDepartmentPositionInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.departmentId = source["departmentId"];
	        this.departmentName = source["departmentName"];
	        this.positionId = source["positionId"];
	        this.positionName = source["positionName"];
	        this.departmentPath = this.convertValues(source["departmentPath"], DepartmentPathNode);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetOrganizeEmployeeByIdRespForApi {
	    id: number;
	    idCard: string;
	    organId: number;
	    name: string;
	    headUrl: string;
	    sex: number;
	    phoneNumber: string;
	    status: number;
	    isInit: number;
	    certificateUrl: string;
	    userName: string;
	    employeeDepartmentPositionInfo: EmployeeDepartmentPositionInfo[];
	    isType: number;
	
	    static createFrom(source: any = {}) {
	        return new GetOrganizeEmployeeByIdRespForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.idCard = source["idCard"];
	        this.organId = source["organId"];
	        this.name = source["name"];
	        this.headUrl = source["headUrl"];
	        this.sex = source["sex"];
	        this.phoneNumber = source["phoneNumber"];
	        this.status = source["status"];
	        this.isInit = source["isInit"];
	        this.certificateUrl = source["certificateUrl"];
	        this.userName = source["userName"];
	        this.employeeDepartmentPositionInfo = this.convertValues(source["employeeDepartmentPositionInfo"], EmployeeDepartmentPositionInfo);
	        this.isType = source["isType"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class DepartmentTreeNode {
	    id: number;
	    departmentName: string;
	    remark: string;
	    parentId: number;
	    children?: DepartmentTreeNode[];
	    employeeList: GetOrganizeEmployeeByIdRespForApi[];
	
	    static createFrom(source: any = {}) {
	        return new DepartmentTreeNode(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.departmentName = source["departmentName"];
	        this.remark = source["remark"];
	        this.parentId = source["parentId"];
	        this.children = this.convertValues(source["children"], DepartmentTreeNode);
	        this.employeeList = this.convertValues(source["employeeList"], GetOrganizeEmployeeByIdRespForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class DepartmentTreeRespForApi {
	    departmentTree: DepartmentTreeNode[];
	
	    static createFrom(source: any = {}) {
	        return new DepartmentTreeRespForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.departmentTree = this.convertValues(source["departmentTree"], DepartmentTreeNode);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class DepartmentTreeRespForApiResp {
	    code: number;
	    msg: string;
	    data: DepartmentTreeRespForApi;
	
	    static createFrom(source: any = {}) {
	        return new DepartmentTreeRespForApiResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], DepartmentTreeRespForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class DeviceActivateInfo {
	    authCode: string;
	    expireAt: number;
	    activateCode: string;
	
	    static createFrom(source: any = {}) {
	        return new DeviceActivateInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.authCode = source["authCode"];
	        this.expireAt = source["expireAt"];
	        this.activateCode = source["activateCode"];
	    }
	}
	export class DeviceActivateInfoResp {
	    data: DeviceActivateInfo;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new DeviceActivateInfoResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], DeviceActivateInfo);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class DeviceDataPayload {
	    code: number;
	    msg: string;
	    deviceSn: string;
	
	    static createFrom(source: any = {}) {
	        return new DeviceDataPayload(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.deviceSn = source["deviceSn"];
	    }
	}
	export class DeviceDataPayloadList {
	    list: DeviceDataPayload[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new DeviceDataPayloadList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], DeviceDataPayload);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class DeviceInfoReq {
	    id: number;
	    deviceSn: string;
	    outCode: string;
	    categoryId: number;
	    brandId: number;
	    typeId: number;
	    typeName: string;
	    deviceName: string;
	    organizeId: number;
	
	    static createFrom(source: any = {}) {
	        return new DeviceInfoReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.deviceSn = source["deviceSn"];
	        this.outCode = source["outCode"];
	        this.categoryId = source["categoryId"];
	        this.brandId = source["brandId"];
	        this.typeId = source["typeId"];
	        this.typeName = source["typeName"];
	        this.deviceName = source["deviceName"];
	        this.organizeId = source["organizeId"];
	    }
	}
	
	export class DeviceRegisterReq {
	    outCode: string;
	    productId: number;
	    deviceRegistBy: number;
	    countryId: number;
	    from: string;
	    activateResultUrl: string;
	
	    static createFrom(source: any = {}) {
	        return new DeviceRegisterReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.outCode = source["outCode"];
	        this.productId = source["productId"];
	        this.deviceRegistBy = source["deviceRegistBy"];
	        this.countryId = source["countryId"];
	        this.from = source["from"];
	        this.activateResultUrl = source["activateResultUrl"];
	    }
	}
	export class DeviceReq {
	    id: number;
	    projectId: number;
	    deviceId: number;
	    deviceSn: string;
	    outCode: string;
	    productsId: number;
	    isAuthentic: number;
	
	    static createFrom(source: any = {}) {
	        return new DeviceReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.projectId = source["projectId"];
	        this.deviceId = source["deviceId"];
	        this.deviceSn = source["deviceSn"];
	        this.outCode = source["outCode"];
	        this.productsId = source["productsId"];
	        this.isAuthentic = source["isAuthentic"];
	    }
	}
	export class DropDownBrandQuery {
	    CategoryId: number;
	
	    static createFrom(source: any = {}) {
	        return new DropDownBrandQuery(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.CategoryId = source["CategoryId"];
	    }
	}
	
	
	
	
	export class FaceModelResponse {
	    code: number;
	    message: string;
	    // Go type: struct { ModelPath string "json:\"model_path\"" }
	    data: any;
	
	    static createFrom(source: any = {}) {
	        return new FaceModelResponse(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.message = source["message"];
	        this.data = this.convertValues(source["data"], Object);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	
	export class FileContent {
	    name: string;
	    path: string;
	    content: string;
	
	    static createFrom(source: any = {}) {
	        return new FileContent(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.name = source["name"];
	        this.path = source["path"];
	        this.content = source["content"];
	    }
	}
	export class FileContentResp {
	    code: number;
	    msg: string;
	    data: FileContent;
	
	    static createFrom(source: any = {}) {
	        return new FileContentResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], FileContent);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class FileInfo {
	    name: string;
	    path: string;
	    isDir: boolean;
	    size: number;
	    modified: string;
	
	    static createFrom(source: any = {}) {
	        return new FileInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.name = source["name"];
	        this.path = source["path"];
	        this.isDir = source["isDir"];
	        this.size = source["size"];
	        this.modified = source["modified"];
	    }
	}
	export class FileInfoResp {
	    code: number;
	    msg: string;
	    data: FileInfo[];
	
	    static createFrom(source: any = {}) {
	        return new FileInfoResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], FileInfo);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class FileUploadData {
	    fileName: string;
	    path: string;
	
	    static createFrom(source: any = {}) {
	        return new FileUploadData(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.fileName = source["fileName"];
	        this.path = source["path"];
	    }
	}
	export class FileUploadResp {
	    code: number;
	    msg: string;
	    data: FileUploadData;
	
	    static createFrom(source: any = {}) {
	        return new FileUploadResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], FileUploadData);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class FrontGlassMeasurements {
	    message: string;
	    code: number;
	    // Go type: struct { ImagePath string "json:\"image_path\""; GlassWidthPixel string "json:\"glass_width_pixel\""; NoseWidthPixel string "json:\"nose_width_pixel\""; LeftGlassHeightPixel string "json:\"left_glass_height_pixel\""; RightGlassHeightPixel string "json:\"right_glass_height_pixel\""; LeftIrisHeightPixel string "json:\"left_iris_height_pixel\""; RightIrisHeightPixel string "json:\"right_iris_height_pixel\""; LeftIrisWidthPixel string "json:\"left_iris_width_pixel\""; RightIrisWidthPixel string "json:\"right_iris_width_pixel\""; GlassWidthMm string "json:\"glass_width_mm\""; NoseWidthMm string "json:\"nose_width_mm\""; LeftGlassHeightMm string "json:\"left_glass_height_mm\""; RightGlassHeightMm string "json:\"right_glass_height_mm\""; LeftIrisHeightMm string "json:\"left_iris_height_mm\""; RightIrisHeightMm string "json:\"right_iris_height_mm\""; LeftIrisWidthMm string "json:\"left_iris_width_mm\""; RightIrisWidthMm string "json:\"right_iris_width_mm\"" }
	    data: any;
	
	    static createFrom(source: any = {}) {
	        return new FrontGlassMeasurements(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.message = source["message"];
	        this.code = source["code"];
	        this.data = this.convertValues(source["data"], Object);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetAfterSaleDetail {
	    desc: string;
	    status: number;
	    time: string;
	
	    static createFrom(source: any = {}) {
	        return new GetAfterSaleDetail(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.desc = source["desc"];
	        this.status = source["status"];
	        this.time = source["time"];
	    }
	}
	export class GetAfterSaleDetailInfo {
	    title: string;
	    outCode: string;
	    content: string;
	    images: string[];
	    createdTime: string;
	    status: number;
	    problemRecord: string;
	    orderCode: string;
	    creaetedOrganName: string;
	    afterSaleTypeId: number;
	    afterSaleTypeName: string;
	    categoryName: string;
	    typeName: string;
	    contact: string;
	    phone: string;
	    processingPlan: string;
	    processingResult: string;
	    processingAttachment: string;
	
	    static createFrom(source: any = {}) {
	        return new GetAfterSaleDetailInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.title = source["title"];
	        this.outCode = source["outCode"];
	        this.content = source["content"];
	        this.images = source["images"];
	        this.createdTime = source["createdTime"];
	        this.status = source["status"];
	        this.problemRecord = source["problemRecord"];
	        this.orderCode = source["orderCode"];
	        this.creaetedOrganName = source["creaetedOrganName"];
	        this.afterSaleTypeId = source["afterSaleTypeId"];
	        this.afterSaleTypeName = source["afterSaleTypeName"];
	        this.categoryName = source["categoryName"];
	        this.typeName = source["typeName"];
	        this.contact = source["contact"];
	        this.phone = source["phone"];
	        this.processingPlan = source["processingPlan"];
	        this.processingResult = source["processingResult"];
	        this.processingAttachment = source["processingAttachment"];
	    }
	}
	export class GetAfterSaleDetailInfoResp {
	    code: number;
	    msg: string;
	    data: GetAfterSaleDetailInfo;
	
	    static createFrom(source: any = {}) {
	        return new GetAfterSaleDetailInfoResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], GetAfterSaleDetailInfo);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetAfterSaleDetailList {
	    process: GetAfterSaleDetail[];
	
	    static createFrom(source: any = {}) {
	        return new GetAfterSaleDetailList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.process = this.convertValues(source["process"], GetAfterSaleDetail);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetAfterSaleDetailListResp {
	    code: number;
	    msg: string;
	    data: GetAfterSaleDetailList;
	
	    static createFrom(source: any = {}) {
	        return new GetAfterSaleDetailListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], GetAfterSaleDetailList);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetAfterSaleDetailReq {
	    orderCode: string;
	
	    static createFrom(source: any = {}) {
	        return new GetAfterSaleDetailReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.orderCode = source["orderCode"];
	    }
	}
	export class GetAfterSaleList {
	    list: AfterSaleInfo[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new GetAfterSaleList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], AfterSaleInfo);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetAfterSaleListReq {
	    page: number;
	    pageSize: number;
	    typeId: number;
	
	    static createFrom(source: any = {}) {
	        return new GetAfterSaleListReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.page = source["page"];
	        this.pageSize = source["pageSize"];
	        this.typeId = source["typeId"];
	    }
	}
	export class GetAfterSaleListResp {
	    code: number;
	    msg: string;
	    data: GetAfterSaleList;
	
	    static createFrom(source: any = {}) {
	        return new GetAfterSaleListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], GetAfterSaleList);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetCustomerInfoByIdReqForApi {
	    Id: number;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new GetCustomerInfoByIdReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.Id = source["Id"];
	        this.organId = source["organId"];
	    }
	}
	export class GetCustomerInfoByIdRespForApi {
	    customer: CustomerForApi;
	
	    static createFrom(source: any = {}) {
	        return new GetCustomerInfoByIdRespForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.customer = this.convertValues(source["customer"], CustomerForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetCustomerInfoByIdResp {
	    code: number;
	    msg: string;
	    data: GetCustomerInfoByIdRespForApi;
	
	    static createFrom(source: any = {}) {
	        return new GetCustomerInfoByIdResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], GetCustomerInfoByIdRespForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	
	export class GetCustomerListReqGetForApi {
	    Page: number;
	    PageSize: number;
	    CustomerName: string;
	    CustomerTel: string;
	    Sex: number;
	    AgeStart: number;
	    AgeEnd: number;
	    CreateAtStart: number;
	    CreateAtEnd: number;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new GetCustomerListReqGetForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.Page = source["Page"];
	        this.PageSize = source["PageSize"];
	        this.CustomerName = source["CustomerName"];
	        this.CustomerTel = source["CustomerTel"];
	        this.Sex = source["Sex"];
	        this.AgeStart = source["AgeStart"];
	        this.AgeEnd = source["AgeEnd"];
	        this.CreateAtStart = source["CreateAtStart"];
	        this.CreateAtEnd = source["CreateAtEnd"];
	        this.organId = source["organId"];
	    }
	}
	export class GetCustomerListRespForApi {
	    total: number;
	    customers: CustomerForApi[];
	
	    static createFrom(source: any = {}) {
	        return new GetCustomerListRespForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.total = source["total"];
	        this.customers = this.convertValues(source["customers"], CustomerForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetCustomerListRespForApiResp {
	    code: number;
	    msg: string;
	    data: GetCustomerListRespForApi;
	
	    static createFrom(source: any = {}) {
	        return new GetCustomerListRespForApiResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], GetCustomerListRespForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class OrderItemForApi {
	    id: number;
	    count: number;
	    goodId: number;
	    goodsTitle: string;
	    priceAtOrder: number;
	    discount: number;
	    amount: number;
	    ignoreStock: number;
	    codes: string[];
	    eyeType: number;
	    goodsId: number;
	    goodsImgAtOrder: string;
	    brandName: string;
	    categoryName: string;
	    typeName: string;
	    goodsCode: string;
	    goodsSpecId: number;
	    goodsSpecName: string;
	    spelling: string;
	    description: string;
	    vipDiscountRate: number;
	    subItemDiscount: number;
	    hasReturnOrder: boolean;
	    returnQuantity: number;
	    nowCodes: string[];
	
	    static createFrom(source: any = {}) {
	        return new OrderItemForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.count = source["count"];
	        this.goodId = source["goodId"];
	        this.goodsTitle = source["goodsTitle"];
	        this.priceAtOrder = source["priceAtOrder"];
	        this.discount = source["discount"];
	        this.amount = source["amount"];
	        this.ignoreStock = source["ignoreStock"];
	        this.codes = source["codes"];
	        this.eyeType = source["eyeType"];
	        this.goodsId = source["goodsId"];
	        this.goodsImgAtOrder = source["goodsImgAtOrder"];
	        this.brandName = source["brandName"];
	        this.categoryName = source["categoryName"];
	        this.typeName = source["typeName"];
	        this.goodsCode = source["goodsCode"];
	        this.goodsSpecId = source["goodsSpecId"];
	        this.goodsSpecName = source["goodsSpecName"];
	        this.spelling = source["spelling"];
	        this.description = source["description"];
	        this.vipDiscountRate = source["vipDiscountRate"];
	        this.subItemDiscount = source["subItemDiscount"];
	        this.hasReturnOrder = source["hasReturnOrder"];
	        this.returnQuantity = source["returnQuantity"];
	        this.nowCodes = source["nowCodes"];
	    }
	}
	export class GetGlassesStoreOrderDetailRespForApi {
	    id: number;
	    orderCode: string;
	    totalAmount: number;
	    paidAmount: number;
	    discount: number;
	    quantity: number;
	    status: number;
	    remark: string;
	    customerId: number;
	    customerName: string;
	    customerTel: string;
	    createdAt: number;
	    updatedAt: number;
	    isProcess: number;
	    checkListId: number;
	    checkCode: string;
	    items: OrderItemForApi[];
	    businessUserId: number;
	    businessUserName: string;
	    businessTime: number;
	    isPaymentRequired: number;
	    actualAmount: number;
	    vipDiscount: number;
	    subTotalDiscount: number;
	    receivableAmount: number;
	    totalDiscount: number;
	
	    static createFrom(source: any = {}) {
	        return new GetGlassesStoreOrderDetailRespForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.orderCode = source["orderCode"];
	        this.totalAmount = source["totalAmount"];
	        this.paidAmount = source["paidAmount"];
	        this.discount = source["discount"];
	        this.quantity = source["quantity"];
	        this.status = source["status"];
	        this.remark = source["remark"];
	        this.customerId = source["customerId"];
	        this.customerName = source["customerName"];
	        this.customerTel = source["customerTel"];
	        this.createdAt = source["createdAt"];
	        this.updatedAt = source["updatedAt"];
	        this.isProcess = source["isProcess"];
	        this.checkListId = source["checkListId"];
	        this.checkCode = source["checkCode"];
	        this.items = this.convertValues(source["items"], OrderItemForApi);
	        this.businessUserId = source["businessUserId"];
	        this.businessUserName = source["businessUserName"];
	        this.businessTime = source["businessTime"];
	        this.isPaymentRequired = source["isPaymentRequired"];
	        this.actualAmount = source["actualAmount"];
	        this.vipDiscount = source["vipDiscount"];
	        this.subTotalDiscount = source["subTotalDiscount"];
	        this.receivableAmount = source["receivableAmount"];
	        this.totalDiscount = source["totalDiscount"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetGlassesStoreOrderDetailRespForApiResp {
	    data: GetGlassesStoreOrderDetailRespForApi;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new GetGlassesStoreOrderDetailRespForApiResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], GetGlassesStoreOrderDetailRespForApi);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetGlassesStoreOrderListReqForApi {
	    Page: number;
	    PageSize: number;
	    Status: number;
	    CustomerInfo: string;
	    OrderCode: string;
	    StartDate: number;
	    EndDate: number;
	    CheckListId: number;
	    CustomerId: number;
	    isPaymentRequired: number;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new GetGlassesStoreOrderListReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.Page = source["Page"];
	        this.PageSize = source["PageSize"];
	        this.Status = source["Status"];
	        this.CustomerInfo = source["CustomerInfo"];
	        this.OrderCode = source["OrderCode"];
	        this.StartDate = source["StartDate"];
	        this.EndDate = source["EndDate"];
	        this.CheckListId = source["CheckListId"];
	        this.CustomerId = source["CustomerId"];
	        this.isPaymentRequired = source["isPaymentRequired"];
	        this.organId = source["organId"];
	    }
	}
	export class GetGlassesStorePurchaseOrderDetailReqForApi {
	    id: number;
	
	    static createFrom(source: any = {}) {
	        return new GetGlassesStorePurchaseOrderDetailReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	    }
	}
	export class GetGlassesStorePurchaseOrderDetailRespForApi {
	    order: GlassesStorePurchaseOrderForApi;
	
	    static createFrom(source: any = {}) {
	        return new GetGlassesStorePurchaseOrderDetailRespForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.order = this.convertValues(source["order"], GlassesStorePurchaseOrderForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetGlassesStorePurchaseOrderDetailRespForApiResp {
	    data: GetGlassesStorePurchaseOrderDetailRespForApi;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new GetGlassesStorePurchaseOrderDetailRespForApiResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], GetGlassesStorePurchaseOrderDetailRespForApi);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetGlassesStorePurchaseOrderListReqForApi {
	    page: number;
	    pageSize: number;
	    status: number;
	    providerInfo: string;
	    startDate: number;
	    endDate: number;
	    orderCode: string;
	    providerId: number;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new GetGlassesStorePurchaseOrderListReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.page = source["page"];
	        this.pageSize = source["pageSize"];
	        this.status = source["status"];
	        this.providerInfo = source["providerInfo"];
	        this.startDate = source["startDate"];
	        this.endDate = source["endDate"];
	        this.orderCode = source["orderCode"];
	        this.providerId = source["providerId"];
	        this.organId = source["organId"];
	    }
	}
	export class GetGlassesStorePurchaseOrderListRespForApi {
	    purchaseOrders: GlassesStorePurchaseOrderForApi[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new GetGlassesStorePurchaseOrderListRespForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.purchaseOrders = this.convertValues(source["purchaseOrders"], GlassesStorePurchaseOrderForApi);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetGlassesStorePurchaseOrderListRespForApiResp {
	    data: GetGlassesStorePurchaseOrderListRespForApi;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new GetGlassesStorePurchaseOrderListRespForApiResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], GetGlassesStorePurchaseOrderListRespForApi);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetOrderLogReq {
	    OrderId: number;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new GetOrderLogReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.OrderId = source["OrderId"];
	        this.organId = source["organId"];
	    }
	}
	export class OrganApiDistribution {
	    id: number;
	    description: string;
	    isDistribution: boolean;
	
	    static createFrom(source: any = {}) {
	        return new OrganApiDistribution(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.description = source["description"];
	        this.isDistribution = source["isDistribution"];
	    }
	}
	export class OrganApiDistributionList {
	    id: number;
	    apiGroup: string;
	    apiGroupName: string;
	    sort: number;
	    apiList: OrganApiDistribution[];
	
	    static createFrom(source: any = {}) {
	        return new OrganApiDistributionList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.apiGroup = source["apiGroup"];
	        this.apiGroupName = source["apiGroupName"];
	        this.sort = source["sort"];
	        this.apiList = this.convertValues(source["apiList"], OrganApiDistribution);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetOrganApiDistributionList {
	    list: OrganApiDistributionList[];
	
	    static createFrom(source: any = {}) {
	        return new GetOrganApiDistributionList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], OrganApiDistributionList);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetOrganApiDistributionListReq {
	    departmentId: number;
	    positionId: number;
	    organId: number;
	    domValue: string;
	
	    static createFrom(source: any = {}) {
	        return new GetOrganApiDistributionListReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.departmentId = source["departmentId"];
	        this.positionId = source["positionId"];
	        this.organId = source["organId"];
	        this.domValue = source["domValue"];
	    }
	}
	export class GetOrganApiDistributionListResp {
	    data: GetOrganApiDistributionList;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new GetOrganApiDistributionListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], GetOrganApiDistributionList);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class OrganMenuDistributionListTree {
	    id: number;
	    parentId: number;
	    sort: number;
	    title: string;
	    isDistribution: boolean;
	    children: OrganMenuDistributionListTree[];
	
	    static createFrom(source: any = {}) {
	        return new OrganMenuDistributionListTree(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.parentId = source["parentId"];
	        this.sort = source["sort"];
	        this.title = source["title"];
	        this.isDistribution = source["isDistribution"];
	        this.children = this.convertValues(source["children"], OrganMenuDistributionListTree);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetOrganMenuDistributionList {
	    list: OrganMenuDistributionListTree[];
	
	    static createFrom(source: any = {}) {
	        return new GetOrganMenuDistributionList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], OrganMenuDistributionListTree);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetOrganMenuDistributionListReq {
	    departmentId: number;
	    positionId: number;
	    organId: number;
	    domValue: string;
	
	    static createFrom(source: any = {}) {
	        return new GetOrganMenuDistributionListReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.departmentId = source["departmentId"];
	        this.positionId = source["positionId"];
	        this.organId = source["organId"];
	        this.domValue = source["domValue"];
	    }
	}
	export class GetOrganMenuDistributionListResp {
	    data: GetOrganMenuDistributionList;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new GetOrganMenuDistributionListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], GetOrganMenuDistributionList);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetOrganizeDepartmentByIdReqForApi {
	    Id: number;
	
	    static createFrom(source: any = {}) {
	        return new GetOrganizeDepartmentByIdReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.Id = source["Id"];
	    }
	}
	export class GetOrganizeDepartmentByIdRespForApi {
	    id: number;
	    departmentName: string;
	    remark: string;
	    parentId: number;
	
	    static createFrom(source: any = {}) {
	        return new GetOrganizeDepartmentByIdRespForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.departmentName = source["departmentName"];
	        this.remark = source["remark"];
	        this.parentId = source["parentId"];
	    }
	}
	export class GetOrganizeDepartmentByIdRespForApiResp {
	    data: GetOrganizeDepartmentByIdRespForApi;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new GetOrganizeDepartmentByIdRespForApiResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], GetOrganizeDepartmentByIdRespForApi);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetOrganizeDepartmentTreeReqForApi {
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new GetOrganizeDepartmentTreeReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.organId = source["organId"];
	    }
	}
	export class GetOrganizeEmployeeByIdReq {
	    Id: number;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new GetOrganizeEmployeeByIdReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.Id = source["Id"];
	        this.organId = source["organId"];
	    }
	}
	
	export class GetOrganizeEmployeeByIdRespForApiResp {
	    code: number;
	    msg: string;
	    data: GetOrganizeEmployeeByIdRespForApi;
	
	    static createFrom(source: any = {}) {
	        return new GetOrganizeEmployeeByIdRespForApiResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], GetOrganizeEmployeeByIdRespForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetOrganizeEmployeeListReqForApi {
	    Page: number;
	    PageSize: number;
	    Name: string;
	    PositionId: number;
	    DepartmentId: number;
	    PhoneNumber: string;
	    Status: number;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new GetOrganizeEmployeeListReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.Page = source["Page"];
	        this.PageSize = source["PageSize"];
	        this.Name = source["Name"];
	        this.PositionId = source["PositionId"];
	        this.DepartmentId = source["DepartmentId"];
	        this.PhoneNumber = source["PhoneNumber"];
	        this.Status = source["Status"];
	        this.organId = source["organId"];
	    }
	}
	export class GetPositionListForDepartmentReqForApi {
	    DepartmentId: number;
	
	    static createFrom(source: any = {}) {
	        return new GetPositionListForDepartmentReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.DepartmentId = source["DepartmentId"];
	    }
	}
	export class GetProviderToOpticianLevelListReqForApi {
	    opticianId: number;
	    page: number;
	    size: number;
	
	    static createFrom(source: any = {}) {
	        return new GetProviderToOpticianLevelListReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.opticianId = source["opticianId"];
	        this.page = source["page"];
	        this.size = source["size"];
	    }
	}
	export class ProviderToOpticianLevelInfo {
	    id: number;
	    level: number;
	    levelName: string;
	    score: number;
	    remark: string;
	
	    static createFrom(source: any = {}) {
	        return new ProviderToOpticianLevelInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.level = source["level"];
	        this.levelName = source["levelName"];
	        this.score = source["score"];
	        this.remark = source["remark"];
	    }
	}
	export class GetProviderToOpticianLevelListRespForApi {
	    total: number;
	    providerToOpticianLevelList: ProviderToOpticianLevelInfo[];
	
	    static createFrom(source: any = {}) {
	        return new GetProviderToOpticianLevelListRespForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.total = source["total"];
	        this.providerToOpticianLevelList = this.convertValues(source["providerToOpticianLevelList"], ProviderToOpticianLevelInfo);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetProviderToOpticianLevelListRespForApiResp {
	    code: number;
	    msg: string;
	    data: GetProviderToOpticianLevelListRespForApi;
	
	    static createFrom(source: any = {}) {
	        return new GetProviderToOpticianLevelListRespForApiResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], GetProviderToOpticianLevelListRespForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetProviderToOpticianListReqForApi {
	    page: number;
	    size: number;
	    providerName: string;
	
	    static createFrom(source: any = {}) {
	        return new GetProviderToOpticianListReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.page = source["page"];
	        this.size = source["size"];
	        this.providerName = source["providerName"];
	    }
	}
	export class ProviderToOpticianInfo {
	    id: number;
	    providerName: string;
	    categoryIds: string;
	    areaName: string;
	    areaId: number;
	    cityName: string;
	    cityId: number;
	    provinceName: string;
	    provinceId: number;
	    streetName: string;
	    streetId: number;
	    address: string;
	    longitude: string;
	    latitude: string;
	    providerPhone: string;
	    tags: string[];
	    level: number;
	    levelName: string;
	    levelId: number;
	    organizeId: number;
	
	    static createFrom(source: any = {}) {
	        return new ProviderToOpticianInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.providerName = source["providerName"];
	        this.categoryIds = source["categoryIds"];
	        this.areaName = source["areaName"];
	        this.areaId = source["areaId"];
	        this.cityName = source["cityName"];
	        this.cityId = source["cityId"];
	        this.provinceName = source["provinceName"];
	        this.provinceId = source["provinceId"];
	        this.streetName = source["streetName"];
	        this.streetId = source["streetId"];
	        this.address = source["address"];
	        this.longitude = source["longitude"];
	        this.latitude = source["latitude"];
	        this.providerPhone = source["providerPhone"];
	        this.tags = source["tags"];
	        this.level = source["level"];
	        this.levelName = source["levelName"];
	        this.levelId = source["levelId"];
	        this.organizeId = source["organizeId"];
	    }
	}
	export class GetProviderToOpticianListRespForApi {
	    total: number;
	    providerToOpticianList: ProviderToOpticianInfo[];
	
	    static createFrom(source: any = {}) {
	        return new GetProviderToOpticianListRespForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.total = source["total"];
	        this.providerToOpticianList = this.convertValues(source["providerToOpticianList"], ProviderToOpticianInfo);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetProviderToOpticianListRespForApiResp {
	    data: GetProviderToOpticianListRespForApi;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new GetProviderToOpticianListRespForApiResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], GetProviderToOpticianListRespForApi);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetRelativesByQueryReq {
	    CustomerId: number;
	    CustomerName: string;
	    CustomerTel: string;
	    Phone: string;
	    BaseRelationId: number;
	    Sex: number;
	    StartDate: number;
	    EndDate: number;
	    Name: string;
	    Page: number;
	    PageSize: number;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new GetRelativesByQueryReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.CustomerId = source["CustomerId"];
	        this.CustomerName = source["CustomerName"];
	        this.CustomerTel = source["CustomerTel"];
	        this.Phone = source["Phone"];
	        this.BaseRelationId = source["BaseRelationId"];
	        this.Sex = source["Sex"];
	        this.StartDate = source["StartDate"];
	        this.EndDate = source["EndDate"];
	        this.Name = source["Name"];
	        this.Page = source["Page"];
	        this.PageSize = source["PageSize"];
	        this.organId = source["organId"];
	    }
	}
	export class GetReturnOrderDetailReqForApi {
	    Id: number;
	
	    static createFrom(source: any = {}) {
	        return new GetReturnOrderDetailReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.Id = source["Id"];
	    }
	}
	export class GetReturnOrderDetailResp {
	    returnOrderCode: string;
	    organId: number;
	    customerId: number;
	    returnAmount: number;
	    quantity: number;
	    returnType: number;
	    remark: string;
	    oldOrderItem: OrderItemForApi;
	    newOrderItem: OrderItemForApi;
	
	    static createFrom(source: any = {}) {
	        return new GetReturnOrderDetailResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.returnOrderCode = source["returnOrderCode"];
	        this.organId = source["organId"];
	        this.customerId = source["customerId"];
	        this.returnAmount = source["returnAmount"];
	        this.quantity = source["quantity"];
	        this.returnType = source["returnType"];
	        this.remark = source["remark"];
	        this.oldOrderItem = this.convertValues(source["oldOrderItem"], OrderItemForApi);
	        this.newOrderItem = this.convertValues(source["newOrderItem"], OrderItemForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetReturnOrderDetailRes {
	    data: GetReturnOrderDetailResp;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new GetReturnOrderDetailRes(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], GetReturnOrderDetailResp);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	
	export class GetReturnOrderListReqForApi {
	    Page: number;
	    PageSize: number;
	    ReturnType: number;
	    CustomerId: number;
	    OldOrderId: number;
	    ReturnOrderCode: string;
	    StartDate: number;
	    EndDate: number;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new GetReturnOrderListReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.Page = source["Page"];
	        this.PageSize = source["PageSize"];
	        this.ReturnType = source["ReturnType"];
	        this.CustomerId = source["CustomerId"];
	        this.OldOrderId = source["OldOrderId"];
	        this.ReturnOrderCode = source["ReturnOrderCode"];
	        this.StartDate = source["StartDate"];
	        this.EndDate = source["EndDate"];
	        this.organId = source["organId"];
	    }
	}
	export class GetStatementsListRespForApi {
	    total: number;
	    list: StatementsForApi[];
	    inAmount: number;
	    outAmount: number;
	    inActualAmount: number;
	    outActualAmount: number;
	
	    static createFrom(source: any = {}) {
	        return new GetStatementsListRespForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.total = source["total"];
	        this.list = this.convertValues(source["list"], StatementsForApi);
	        this.inAmount = source["inAmount"];
	        this.outAmount = source["outAmount"];
	        this.inActualAmount = source["inActualAmount"];
	        this.outActualAmount = source["outActualAmount"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetStatementsListReqForApiResp {
	    code: number;
	    msg: string;
	    data: GetStatementsListRespForApi;
	
	    static createFrom(source: any = {}) {
	        return new GetStatementsListReqForApiResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], GetStatementsListRespForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class OrganQuery {
	    organizeId: number;
	    startTime: number;
	    endTime: number;
	
	    static createFrom(source: any = {}) {
	        return new OrganQuery(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.organizeId = source["organizeId"];
	        this.startTime = source["startTime"];
	        this.endTime = source["endTime"];
	    }
	}
	export class GetStatementsListReqForBranchReq {
	    organIds: number[];
	    organQueries: OrganQuery[];
	    orderCode: string;
	    page: number;
	    size: number;
	    bType: number;
	    orderType: number;
	    startDate: number;
	    endDate: number;
	    createName: string;
	
	    static createFrom(source: any = {}) {
	        return new GetStatementsListReqForBranchReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.organIds = source["organIds"];
	        this.organQueries = this.convertValues(source["organQueries"], OrganQuery);
	        this.orderCode = source["orderCode"];
	        this.page = source["page"];
	        this.size = source["size"];
	        this.bType = source["bType"];
	        this.orderType = source["orderType"];
	        this.startDate = source["startDate"];
	        this.endDate = source["endDate"];
	        this.createName = source["createName"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	
	export class TodoTaskInfoForApi {
	    id: number;
	    remindTime: number;
	    title: string;
	    content: string;
	    status: number;
	    apiUrl: string;
	    msgSourceType: number;
	    msgSendId: number;
	    paramValue: string;
	    taskTypeId: number;
	    opType: number;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new TodoTaskInfoForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.remindTime = source["remindTime"];
	        this.title = source["title"];
	        this.content = source["content"];
	        this.status = source["status"];
	        this.apiUrl = source["apiUrl"];
	        this.msgSourceType = source["msgSourceType"];
	        this.msgSendId = source["msgSendId"];
	        this.paramValue = source["paramValue"];
	        this.taskTypeId = source["taskTypeId"];
	        this.opType = source["opType"];
	        this.organId = source["organId"];
	    }
	}
	export class GetTodoTaskListResp {
	    total: number;
	    todoTaskList: TodoTaskInfoForApi[];
	
	    static createFrom(source: any = {}) {
	        return new GetTodoTaskListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.total = source["total"];
	        this.todoTaskList = this.convertValues(source["todoTaskList"], TodoTaskInfoForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetTodoTaskResp {
	    data: GetTodoTaskListResp;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new GetTodoTaskResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], GetTodoTaskListResp);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	
	export class GetVisitCycleByCustomerReqForApi {
	    Id: number;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new GetVisitCycleByCustomerReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.Id = source["Id"];
	        this.organId = source["organId"];
	    }
	}
	export class GetVisitCycleByCustomerRespForApi {
	    visitCycleDays: number;
	    reminderSwitch: number;
	    whyVisit: string;
	
	    static createFrom(source: any = {}) {
	        return new GetVisitCycleByCustomerRespForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.visitCycleDays = source["visitCycleDays"];
	        this.reminderSwitch = source["reminderSwitch"];
	        this.whyVisit = source["whyVisit"];
	    }
	}
	export class GetVisitCycleByCustomerRespForApiResp {
	    code: number;
	    msg: string;
	    data: GetVisitCycleByCustomerRespForApi;
	
	    static createFrom(source: any = {}) {
	        return new GetVisitCycleByCustomerRespForApiResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], GetVisitCycleByCustomerRespForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GetVisitRecordListReqForBranch {
	    organIds: number[];
	    organQueries: OrganQuery[];
	    customerName: string;
	    customerTel: string;
	    startTime: number;
	    endTime: number;
	    page: number;
	    pageSize: number;
	
	    static createFrom(source: any = {}) {
	        return new GetVisitRecordListReqForBranch(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.organIds = source["organIds"];
	        this.organQueries = this.convertValues(source["organQueries"], OrganQuery);
	        this.customerName = source["customerName"];
	        this.customerTel = source["customerTel"];
	        this.startTime = source["startTime"];
	        this.endTime = source["endTime"];
	        this.page = source["page"];
	        this.pageSize = source["pageSize"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GlassMeasurements {
	    code: number;
	    message: string;
	    // Go type: struct { ImagePath string "json:\"image_path\""; GlassesLegLengthInfo [][]int "json:\"glasses_leg_length_info\""; GlassesEyeLengthInfo [][]int "json:\"glasses_eye_length_info\""; TiltAngleInfo [][]int "json:\"tilt_angle_info\""; DataPixelInfo []float64 "json:\"data_pixel_info\""; DataMmInfo []float64 "json:\"data_mm_info\"" }
	    data: any;
	
	    static createFrom(source: any = {}) {
	        return new GlassMeasurements(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.message = source["message"];
	        this.data = this.convertValues(source["data"], Object);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GlassesInfoReq {
	    id: number;
	    checklistId: number;
	    glassesResult: string;
	    glassesAdvice: string;
	    trialPlan: string;
	    other: string;
	
	    static createFrom(source: any = {}) {
	        return new GlassesInfoReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.checklistId = source["checklistId"];
	        this.glassesResult = source["glassesResult"];
	        this.glassesAdvice = source["glassesAdvice"];
	        this.trialPlan = source["trialPlan"];
	        this.other = source["other"];
	    }
	}
	export class GlassesInfoReqResp {
	    code: number;
	    msg: string;
	    data: GlassesInfoReq;
	
	    static createFrom(source: any = {}) {
	        return new GlassesInfoReqResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], GlassesInfoReq);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	
	
	export class GlassesStorePurchaseOrderRecordForApi {
	    id: number;
	    providerId: number;
	    organId: number;
	    totalAmount: number;
	    paidAmount: number;
	    discount: number;
	    quantity: number;
	    status: number;
	    remark: string;
	    providerName: string;
	    providerPhone: string;
	    createdAt: number;
	    orderCode: string;
	    createUserId: number;
	    createUserName: string;
	    updateUserId: number;
	    updateUserName: string;
	    inventoryCount: number;
	    logInfo: string;
	    businessUserId: number;
	    businessUserName: string;
	    businessTime: number;
	
	    static createFrom(source: any = {}) {
	        return new GlassesStorePurchaseOrderRecordForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.providerId = source["providerId"];
	        this.organId = source["organId"];
	        this.totalAmount = source["totalAmount"];
	        this.paidAmount = source["paidAmount"];
	        this.discount = source["discount"];
	        this.quantity = source["quantity"];
	        this.status = source["status"];
	        this.remark = source["remark"];
	        this.providerName = source["providerName"];
	        this.providerPhone = source["providerPhone"];
	        this.createdAt = source["createdAt"];
	        this.orderCode = source["orderCode"];
	        this.createUserId = source["createUserId"];
	        this.createUserName = source["createUserName"];
	        this.updateUserId = source["updateUserId"];
	        this.updateUserName = source["updateUserName"];
	        this.inventoryCount = source["inventoryCount"];
	        this.logInfo = source["logInfo"];
	        this.businessUserId = source["businessUserId"];
	        this.businessUserName = source["businessUserName"];
	        this.businessTime = source["businessTime"];
	    }
	}
	export class GlassesStorePurchaseOrderRecordListReqForApi {
	    orderId: number;
	    page: number;
	    size: number;
	
	    static createFrom(source: any = {}) {
	        return new GlassesStorePurchaseOrderRecordListReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.orderId = source["orderId"];
	        this.page = source["page"];
	        this.size = source["size"];
	    }
	}
	export class GlassesStorePurchaseOrderRecordListRespForApi {
	    total: number;
	    list: GlassesStorePurchaseOrderRecordForApi[];
	
	    static createFrom(source: any = {}) {
	        return new GlassesStorePurchaseOrderRecordListRespForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.total = source["total"];
	        this.list = this.convertValues(source["list"], GlassesStorePurchaseOrderRecordForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GlassesStorePurchaseOrderRecordListRespForApiResp {
	    data: GlassesStorePurchaseOrderRecordListRespForApi;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new GlassesStorePurchaseOrderRecordListRespForApiResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], GlassesStorePurchaseOrderRecordListRespForApi);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GoodsDictDataItem {
	    id: number;
	    children: GoodsDictDataItem[];
	    dictLabel: string;
	
	    static createFrom(source: any = {}) {
	        return new GoodsDictDataItem(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.children = this.convertValues(source["children"], GoodsDictDataItem);
	        this.dictLabel = source["dictLabel"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GoodsDictionaryItem {
	    id: number;
	    multiSelect: number;
	    selectId: number;
	    dictMode: number;
	    dictValue: number;
	    dictTypeLabel: string;
	    dictData: GoodsDictDataItem[];
	    xDictData: GoodsDictDataItem[];
	    yDictData: GoodsDictDataItem[];
	
	    static createFrom(source: any = {}) {
	        return new GoodsDictionaryItem(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.multiSelect = source["multiSelect"];
	        this.selectId = source["selectId"];
	        this.dictMode = source["dictMode"];
	        this.dictValue = source["dictValue"];
	        this.dictTypeLabel = source["dictTypeLabel"];
	        this.dictData = this.convertValues(source["dictData"], GoodsDictDataItem);
	        this.xDictData = this.convertValues(source["xDictData"], GoodsDictDataItem);
	        this.yDictData = this.convertValues(source["yDictData"], GoodsDictDataItem);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GoodsAddInfo {
	    id: number;
	    brandId: number;
	    categoryId: number;
	    supplierId: number;
	    supplierName: string;
	    isCustomized: number;
	    typeId: number;
	    typeName: string;
	    categoryName: string;
	    brandName: string;
	    myCode: string;
	    goodsTitle: string;
	    spelling: string;
	    isSelling: number;
	    generalId: number;
	    description: string;
	    goodsImg: string;
	    list: GoodsDictionaryItem[];
	    commonFiles: CommonFileItem[];
	
	    static createFrom(source: any = {}) {
	        return new GoodsAddInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.brandId = source["brandId"];
	        this.categoryId = source["categoryId"];
	        this.supplierId = source["supplierId"];
	        this.supplierName = source["supplierName"];
	        this.isCustomized = source["isCustomized"];
	        this.typeId = source["typeId"];
	        this.typeName = source["typeName"];
	        this.categoryName = source["categoryName"];
	        this.brandName = source["brandName"];
	        this.myCode = source["myCode"];
	        this.goodsTitle = source["goodsTitle"];
	        this.spelling = source["spelling"];
	        this.isSelling = source["isSelling"];
	        this.generalId = source["generalId"];
	        this.description = source["description"];
	        this.goodsImg = source["goodsImg"];
	        this.list = this.convertValues(source["list"], GoodsDictionaryItem);
	        this.commonFiles = this.convertValues(source["commonFiles"], CommonFileItem);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GoodsCategory {
	    id: number;
	    categoryName: string;
	
	    static createFrom(source: any = {}) {
	        return new GoodsCategory(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.categoryName = source["categoryName"];
	    }
	}
	export class GoodsCategoryList {
	    list: GoodsCategory[];
	
	    static createFrom(source: any = {}) {
	        return new GoodsCategoryList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], GoodsCategory);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GoodsCategoryResp {
	    data: GoodsCategoryList;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new GoodsCategoryResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], GoodsCategoryList);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	
	
	export class GoodsInfo {
	    id: number;
	    goodsImg: string;
	    brandName: string;
	    categoryName: string;
	    typeName: string;
	    brandId: number;
	    categoryId: number;
	    typeId: number;
	    description: string;
	    supplierId: number;
	    supplierName: string;
	    weight: number;
	    generalId: number;
	    isSelling: number;
	    goodsPrice: number;
	    goodsTitle: string;
	    myCode: string;
	    spelling: string;
	    isCustomized: number;
	    isModified: number;
	    commonFiles: CommonFileItem[];
	
	    static createFrom(source: any = {}) {
	        return new GoodsInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.goodsImg = source["goodsImg"];
	        this.brandName = source["brandName"];
	        this.categoryName = source["categoryName"];
	        this.typeName = source["typeName"];
	        this.brandId = source["brandId"];
	        this.categoryId = source["categoryId"];
	        this.typeId = source["typeId"];
	        this.description = source["description"];
	        this.supplierId = source["supplierId"];
	        this.supplierName = source["supplierName"];
	        this.weight = source["weight"];
	        this.generalId = source["generalId"];
	        this.isSelling = source["isSelling"];
	        this.goodsPrice = source["goodsPrice"];
	        this.goodsTitle = source["goodsTitle"];
	        this.myCode = source["myCode"];
	        this.spelling = source["spelling"];
	        this.isCustomized = source["isCustomized"];
	        this.isModified = source["isModified"];
	        this.commonFiles = this.convertValues(source["commonFiles"], CommonFileItem);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GoodsInfoResp {
	    data: GoodsInfo;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new GoodsInfoResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], GoodsInfo);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GoodsItem {
	    id: number;
	    myCode: string;
	    goodsImg: string;
	    brandName: string;
	    categoryName: string;
	    typeName: string;
	    description: string;
	    goodsTitle: string;
	    spelling: string;
	    isSelling: number;
	    categoryId: number;
	    producerGoodsCode: string;
	    isCustomized: number;
	
	    static createFrom(source: any = {}) {
	        return new GoodsItem(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.myCode = source["myCode"];
	        this.goodsImg = source["goodsImg"];
	        this.brandName = source["brandName"];
	        this.categoryName = source["categoryName"];
	        this.typeName = source["typeName"];
	        this.description = source["description"];
	        this.goodsTitle = source["goodsTitle"];
	        this.spelling = source["spelling"];
	        this.isSelling = source["isSelling"];
	        this.categoryId = source["categoryId"];
	        this.producerGoodsCode = source["producerGoodsCode"];
	        this.isCustomized = source["isCustomized"];
	    }
	}
	export class GoodsList {
	    list: GoodsItem[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new GoodsList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], GoodsItem);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GoodsSpecsValueItem {
	    id: number;
	    specsValueName: string;
	
	    static createFrom(source: any = {}) {
	        return new GoodsSpecsValueItem(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.specsValueName = source["specsValueName"];
	    }
	}
	export class GoodsSpecsItem {
	    id: number;
	    specsName: string;
	    list: GoodsSpecsValueItem[];
	
	    static createFrom(source: any = {}) {
	        return new GoodsSpecsItem(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.specsName = source["specsName"];
	        this.list = this.convertValues(source["list"], GoodsSpecsValueItem);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GoodsListByDictTypeReq {
	    generalId: number;
	    categoryId: number;
	    storeId: number;
	    keyword: string;
	    ids: number[];
	    specsList: GoodsSpecsItem[];
	    parentId: number;
	    supplierOrganizeId: number;
	    page: number;
	    pageSize: number;
	
	    static createFrom(source: any = {}) {
	        return new GoodsListByDictTypeReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.generalId = source["generalId"];
	        this.categoryId = source["categoryId"];
	        this.storeId = source["storeId"];
	        this.keyword = source["keyword"];
	        this.ids = source["ids"];
	        this.specsList = this.convertValues(source["specsList"], GoodsSpecsItem);
	        this.parentId = source["parentId"];
	        this.supplierOrganizeId = source["supplierOrganizeId"];
	        this.page = source["page"];
	        this.pageSize = source["pageSize"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GoodsListResp {
	    data: GoodsList;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new GoodsListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], GoodsList);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GoodsQueryId {
	    Id: number;
	    ParentId: number;
	
	    static createFrom(source: any = {}) {
	        return new GoodsQueryId(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.Id = source["Id"];
	        this.ParentId = source["ParentId"];
	    }
	}
	export class GoodsQueryParams {
	    Spelling: string;
	    MyCode: string;
	    GoodsTitle: string;
	    IsSelling: number;
	    Page: number;
	    PageSize: number;
	    BrandId: number;
	    CategoryId: number;
	    TypeId: number;
	
	    static createFrom(source: any = {}) {
	        return new GoodsQueryParams(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.Spelling = source["Spelling"];
	        this.MyCode = source["MyCode"];
	        this.GoodsTitle = source["GoodsTitle"];
	        this.IsSelling = source["IsSelling"];
	        this.Page = source["Page"];
	        this.PageSize = source["PageSize"];
	        this.BrandId = source["BrandId"];
	        this.CategoryId = source["CategoryId"];
	        this.TypeId = source["TypeId"];
	    }
	}
	export class GoodsSpecAddInfo {
	    id: number;
	    goodsId: number;
	    goodsPrice: number;
	    specsList: GoodsSpecsItem[];
	
	    static createFrom(source: any = {}) {
	        return new GoodsSpecAddInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.goodsId = source["goodsId"];
	        this.goodsPrice = source["goodsPrice"];
	        this.specsList = this.convertValues(source["specsList"], GoodsSpecsItem);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GoodsSpecDeleteParams {
	    id: number;
	    goodsId: number;
	
	    static createFrom(source: any = {}) {
	        return new GoodsSpecDeleteParams(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.goodsId = source["goodsId"];
	    }
	}
	export class GoodsSpecInfoResp {
	    data: GoodsSpecAddInfo;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new GoodsSpecInfoResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], GoodsSpecAddInfo);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	
	export class GoodsSpecsList {
	    list: GoodsSpecsItem[];
	
	    static createFrom(source: any = {}) {
	        return new GoodsSpecsList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], GoodsSpecsItem);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GoodsSpecsListResp {
	    data: GoodsSpecsList;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new GoodsSpecsListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], GoodsSpecsList);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	
	export class GoodsTotalCategory {
	    id: number;
	    name: string;
	
	    static createFrom(source: any = {}) {
	        return new GoodsTotalCategory(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	    }
	}
	export class GoodsTotalCategoryList {
	    list: GoodsTotalCategory[];
	
	    static createFrom(source: any = {}) {
	        return new GoodsTotalCategoryList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], GoodsTotalCategory);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GoodsTotalCategoryResp {
	    data: GoodsTotalCategoryList;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new GoodsTotalCategoryResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], GoodsTotalCategoryList);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GoodsTypeBaseInfo {
	    id: number;
	    typeName: string;
	
	    static createFrom(source: any = {}) {
	        return new GoodsTypeBaseInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.typeName = source["typeName"];
	    }
	}
	export class GoodsTypeDropDownList {
	    list: GoodsTypeBaseInfo[];
	
	    static createFrom(source: any = {}) {
	        return new GoodsTypeDropDownList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], GoodsTypeBaseInfo);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GoodsTypeDropDownListResp {
	    data: GoodsTypeDropDownList;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new GoodsTypeDropDownListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], GoodsTypeDropDownList);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GoodsTypeQueryId {
	    Id: number;
	    BrandId: number;
	
	    static createFrom(source: any = {}) {
	        return new GoodsTypeQueryId(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.Id = source["Id"];
	        this.BrandId = source["BrandId"];
	    }
	}
	export class SpecsTypeWithValues {
	    id: number;
	    specsName: string;
	    specsValueName: string;
	
	    static createFrom(source: any = {}) {
	        return new SpecsTypeWithValues(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.specsName = source["specsName"];
	        this.specsValueName = source["specsValueName"];
	    }
	}
	export class GoodsWithSpecsItem {
	    id: number;
	    goodsId: number;
	    goodsPrice: number;
	    specsValueIds: number[];
	    specs: SpecsTypeWithValues[];
	
	    static createFrom(source: any = {}) {
	        return new GoodsWithSpecsItem(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.goodsId = source["goodsId"];
	        this.goodsPrice = source["goodsPrice"];
	        this.specsValueIds = source["specsValueIds"];
	        this.specs = this.convertValues(source["specs"], SpecsTypeWithValues);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GoodsWithSpecsList {
	    list: GoodsWithSpecsItem[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new GoodsWithSpecsList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], GoodsWithSpecsItem);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GoodsWithSpecsListResp {
	    data: GoodsWithSpecsList;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new GoodsWithSpecsListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], GoodsWithSpecsList);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class GoodsWithSpecsQuery {
	    goodsId: number;
	    specsList: GoodsSpecsItem[];
	    page: number;
	    pageSize: number;
	
	    static createFrom(source: any = {}) {
	        return new GoodsWithSpecsQuery(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.goodsId = source["goodsId"];
	        this.specsList = this.convertValues(source["specsList"], GoodsSpecsItem);
	        this.page = source["page"];
	        this.pageSize = source["pageSize"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class IdReq {
	    id: number;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new IdReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.organId = source["organId"];
	    }
	}
	export class IdsReq {
	    ids: number[];
	
	    static createFrom(source: any = {}) {
	        return new IdsReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.ids = source["ids"];
	    }
	}
	export class JsResp {
	    code: number;
	    msg: string;
	    data: any;
	
	    static createFrom(source: any = {}) {
	        return new JsResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = source["data"];
	    }
	}
	
	export class ListCityBaseInfo {
	    list: CityBaseInfo[];
	
	    static createFrom(source: any = {}) {
	        return new ListCityBaseInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], CityBaseInfo);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ListCityBaseInfoResp {
	    data: ListCityBaseInfo;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new ListCityBaseInfoResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], ListCityBaseInfo);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ListDataBridgeReq {
	    page: number;
	    size: number;
	    srcOutCode: string;
	
	    static createFrom(source: any = {}) {
	        return new ListDataBridgeReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.page = source["page"];
	        this.size = source["size"];
	        this.srcOutCode = source["srcOutCode"];
	    }
	}
	export class ListDataBridgeResp {
	    data: DataBridgeList;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new ListDataBridgeResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], DataBridgeList);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ListDeviceByOutCodeAndNameReq {
	    page: number;
	    pageSize: number;
	
	    static createFrom(source: any = {}) {
	        return new ListDeviceByOutCodeAndNameReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.page = source["page"];
	        this.pageSize = source["pageSize"];
	    }
	}
	export class TypeData {
	    id: number;
	    categoryId: number;
	    categoryName: string;
	    brandId: number;
	    brandName: string;
	    typeId: number;
	    typeName: string;
	
	    static createFrom(source: any = {}) {
	        return new TypeData(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.categoryId = source["categoryId"];
	        this.categoryName = source["categoryName"];
	        this.brandId = source["brandId"];
	        this.brandName = source["brandName"];
	        this.typeId = source["typeId"];
	        this.typeName = source["typeName"];
	    }
	}
	export class ProjectDataForApi {
	    id: number;
	    createdAt: string;
	    updatedAt: string;
	    projectName: string;
	    remark: string;
	    isCustomize: number;
	    deviceList: DeviceReq[];
	    dataIds: number[];
	    isDefmod: number;
	    status: number;
	    templateId: number;
	    typeList: TypeData[];
	    sort: number;
	
	    static createFrom(source: any = {}) {
	        return new ProjectDataForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.createdAt = source["createdAt"];
	        this.updatedAt = source["updatedAt"];
	        this.projectName = source["projectName"];
	        this.remark = source["remark"];
	        this.isCustomize = source["isCustomize"];
	        this.deviceList = this.convertValues(source["deviceList"], DeviceReq);
	        this.dataIds = source["dataIds"];
	        this.isDefmod = source["isDefmod"];
	        this.status = source["status"];
	        this.templateId = source["templateId"];
	        this.typeList = this.convertValues(source["typeList"], TypeData);
	        this.sort = source["sort"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ListDeviceResp {
	    list: ProjectDataForApi[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new ListDeviceResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], ProjectDataForApi);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ListDeviceRespResp {
	    code: number;
	    msg: string;
	    data: ListDeviceResp;
	
	    static createFrom(source: any = {}) {
	        return new ListDeviceRespResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], ListDeviceResp);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class RankingData {
	    id: number;
	    name: string;
	    count: number;
	    children: RankingData[];
	
	    static createFrom(source: any = {}) {
	        return new RankingData(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.name = source["name"];
	        this.count = source["count"];
	        this.children = this.convertValues(source["children"], RankingData);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ListRanking {
	    list: RankingData[];
	
	    static createFrom(source: any = {}) {
	        return new ListRanking(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], RankingData);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ListReq {
	    Page: number;
	    Size: number;
	    Query: string;
	    OrganId: number;
	    IsCustomize: number;
	    IsDefmod: number;
	    ProjectName: string;
	    Status: number;
	
	    static createFrom(source: any = {}) {
	        return new ListReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.Page = source["Page"];
	        this.Size = source["Size"];
	        this.Query = source["Query"];
	        this.OrganId = source["OrganId"];
	        this.IsCustomize = source["IsCustomize"];
	        this.IsDefmod = source["IsDefmod"];
	        this.ProjectName = source["ProjectName"];
	        this.Status = source["Status"];
	    }
	}
	export class LocalCommonResponse {
	    code: number;
	    message: string;
	
	    static createFrom(source: any = {}) {
	        return new LocalCommonResponse(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.message = source["message"];
	    }
	}
	
	
	export class MqttAuthCodeForApi {
	    id: number;
	    createdTime: number;
	    updatedTime: number;
	    deviceSn: string;
	    doctorUsername: string;
	    doctorNickname: string;
	    authExpireTime: number;
	    status: number;
	    outCode: string;
	    categoryName: string;
	    brandName: string;
	    typeName: string;
	    authCode: string;
	
	    static createFrom(source: any = {}) {
	        return new MqttAuthCodeForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.createdTime = source["createdTime"];
	        this.updatedTime = source["updatedTime"];
	        this.deviceSn = source["deviceSn"];
	        this.doctorUsername = source["doctorUsername"];
	        this.doctorNickname = source["doctorNickname"];
	        this.authExpireTime = source["authExpireTime"];
	        this.status = source["status"];
	        this.outCode = source["outCode"];
	        this.categoryName = source["categoryName"];
	        this.brandName = source["brandName"];
	        this.typeName = source["typeName"];
	        this.authCode = source["authCode"];
	    }
	}
	export class MqttAuthCodeList {
	    list: MqttAuthCodeForApi[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new MqttAuthCodeList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], MqttAuthCodeForApi);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class MqttAuthCodeListReq {
	    page: number;
	    size: number;
	    deviceSn: string;
	    doctorUsername: string;
	    doctorNickname: string;
	    authExpireTime: number;
	
	    static createFrom(source: any = {}) {
	        return new MqttAuthCodeListReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.page = source["page"];
	        this.size = source["size"];
	        this.deviceSn = source["deviceSn"];
	        this.doctorUsername = source["doctorUsername"];
	        this.doctorNickname = source["doctorNickname"];
	        this.authExpireTime = source["authExpireTime"];
	    }
	}
	export class MqttAuthCodeListResp {
	    data: MqttAuthCodeList;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new MqttAuthCodeListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], MqttAuthCodeList);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class MqttAuthCodeUpdateReq {
	    id: number;
	    authExpireTime: number;
	
	    static createFrom(source: any = {}) {
	        return new MqttAuthCodeUpdateReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.authExpireTime = source["authExpireTime"];
	    }
	}
	export class MqttAuthCodeUpdateStatusReq {
	    id: number;
	    status: number;
	
	    static createFrom(source: any = {}) {
	        return new MqttAuthCodeUpdateStatusReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.status = source["status"];
	    }
	}
	export class NotSalingParams {
	    id: number;
	    isSelling: number;
	
	    static createFrom(source: any = {}) {
	        return new NotSalingParams(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.isSelling = source["isSelling"];
	    }
	}
	
	
	export class OrderLogInfo {
	    logInfo: string;
	    createTime: string;
	
	    static createFrom(source: any = {}) {
	        return new OrderLogInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.logInfo = source["logInfo"];
	        this.createTime = source["createTime"];
	    }
	}
	export class OrderLogList {
	    list: OrderLogInfo[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new OrderLogList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], OrderLogInfo);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class OrderLogListResp {
	    data: OrderLogList;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new OrderLogListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], OrderLogList);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class OrderWithCustomerForListForApi {
	    id: number;
	    orderCode: string;
	    totalAmount: number;
	    paidAmount: number;
	    discount: number;
	    quantity: number;
	    status: number;
	    remark: string;
	    customerName: string;
	    customerTel: string;
	    isProcess: number;
	    checkListId: number;
	    checkCode: string;
	    createdAt: number;
	    updatedAt: number;
	    businessUserId: number;
	    businessUserName: string;
	    businessTime: number;
	    eyeType: number;
	    customerId: number;
	    isPaymentRequired: number;
	    actualAmount: number;
	    vipDiscount: number;
	    subTotalDiscount: number;
	    receivableAmount: number;
	    totalDiscount: number;
	
	    static createFrom(source: any = {}) {
	        return new OrderWithCustomerForListForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.orderCode = source["orderCode"];
	        this.totalAmount = source["totalAmount"];
	        this.paidAmount = source["paidAmount"];
	        this.discount = source["discount"];
	        this.quantity = source["quantity"];
	        this.status = source["status"];
	        this.remark = source["remark"];
	        this.customerName = source["customerName"];
	        this.customerTel = source["customerTel"];
	        this.isProcess = source["isProcess"];
	        this.checkListId = source["checkListId"];
	        this.checkCode = source["checkCode"];
	        this.createdAt = source["createdAt"];
	        this.updatedAt = source["updatedAt"];
	        this.businessUserId = source["businessUserId"];
	        this.businessUserName = source["businessUserName"];
	        this.businessTime = source["businessTime"];
	        this.eyeType = source["eyeType"];
	        this.customerId = source["customerId"];
	        this.isPaymentRequired = source["isPaymentRequired"];
	        this.actualAmount = source["actualAmount"];
	        this.vipDiscount = source["vipDiscount"];
	        this.subTotalDiscount = source["subTotalDiscount"];
	        this.receivableAmount = source["receivableAmount"];
	        this.totalDiscount = source["totalDiscount"];
	    }
	}
	export class OrderWithCustomerForListForApiList {
	    list: OrderWithCustomerForListForApi[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new OrderWithCustomerForListForApiList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], OrderWithCustomerForListForApi);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class OrderWithCustomerForListForApiListResp {
	    data: OrderWithCustomerForListForApiList;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new OrderWithCustomerForListForApiListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], OrderWithCustomerForListForApiList);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	
	
	export class OrganIdReq {
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new OrganIdReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.organId = source["organId"];
	    }
	}
	
	
	
	export class OrganizeEmployeeForListRespForApi {
	    id: number;
	    idCard: string;
	    organId: number;
	    name: string;
	    headUrl: string;
	    sex: number;
	    phoneNumber: string;
	    userName: string;
	    userId: number;
	    status: number;
	    isInit: number;
	    departmentPositionInfo: EmployeeDepartmentPositionInfo[];
	
	    static createFrom(source: any = {}) {
	        return new OrganizeEmployeeForListRespForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.idCard = source["idCard"];
	        this.organId = source["organId"];
	        this.name = source["name"];
	        this.headUrl = source["headUrl"];
	        this.sex = source["sex"];
	        this.phoneNumber = source["phoneNumber"];
	        this.userName = source["userName"];
	        this.userId = source["userId"];
	        this.status = source["status"];
	        this.isInit = source["isInit"];
	        this.departmentPositionInfo = this.convertValues(source["departmentPositionInfo"], EmployeeDepartmentPositionInfo);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class OrganizeEmployeeForListRespForApiList {
	    list: OrganizeEmployeeForListRespForApi[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new OrganizeEmployeeForListRespForApiList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], OrganizeEmployeeForListRespForApi);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class OrganizeEmployeeForListRespForApiListResp {
	    code: number;
	    msg: string;
	    data: OrganizeEmployeeForListRespForApiList;
	
	    static createFrom(source: any = {}) {
	        return new OrganizeEmployeeForListRespForApiListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], OrganizeEmployeeForListRespForApiList);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class OrganizeGoodsCode {
	    myCode: string;
	
	    static createFrom(source: any = {}) {
	        return new OrganizeGoodsCode(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.myCode = source["myCode"];
	    }
	}
	export class OrganizeGoodsCodeResp {
	    data: OrganizeGoodsCode;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new OrganizeGoodsCodeResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], OrganizeGoodsCode);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class OrganizeGoodsItem {
	    id: number;
	    goodsId: number;
	    myCode: string;
	    producerGoodsCode: string;
	    isCustomized: number;
	    spelling: string;
	    goodsImg: string;
	    brandName: string;
	    categoryName: string;
	    typeName: string;
	    goodsTitle: string;
	    typeId: number;
	    goodsPrice: number;
	    producerGoodsId: number;
	    specsDescription: string;
	    supplierName: string;
	    description: string;
	    inventory: number;
	    supplierInventory: number;
	
	    static createFrom(source: any = {}) {
	        return new OrganizeGoodsItem(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.goodsId = source["goodsId"];
	        this.myCode = source["myCode"];
	        this.producerGoodsCode = source["producerGoodsCode"];
	        this.isCustomized = source["isCustomized"];
	        this.spelling = source["spelling"];
	        this.goodsImg = source["goodsImg"];
	        this.brandName = source["brandName"];
	        this.categoryName = source["categoryName"];
	        this.typeName = source["typeName"];
	        this.goodsTitle = source["goodsTitle"];
	        this.typeId = source["typeId"];
	        this.goodsPrice = source["goodsPrice"];
	        this.producerGoodsId = source["producerGoodsId"];
	        this.specsDescription = source["specsDescription"];
	        this.supplierName = source["supplierName"];
	        this.description = source["description"];
	        this.inventory = source["inventory"];
	        this.supplierInventory = source["supplierInventory"];
	    }
	}
	export class OrganizeGoodsList {
	    list: OrganizeGoodsItem[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new OrganizeGoodsList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], OrganizeGoodsItem);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class OrganizeGoodsResp {
	    data: OrganizeGoodsList;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new OrganizeGoodsResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], OrganizeGoodsList);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	
	export class PositionForListResp {
	    id: number;
	    positionName: string;
	    remark: string;
	
	    static createFrom(source: any = {}) {
	        return new PositionForListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.positionName = source["positionName"];
	        this.remark = source["remark"];
	    }
	}
	export class PositionForListRespList {
	    list: PositionForListResp[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new PositionForListRespList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], PositionForListResp);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class PositionForListRespListResp {
	    code: number;
	    msg: string;
	    data: PositionForListRespList;
	
	    static createFrom(source: any = {}) {
	        return new PositionForListRespListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], PositionForListRespList);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class PreferenceInfo {
	    id: number;
	    word: string;
	    organId: number;
	    typeName: string;
	
	    static createFrom(source: any = {}) {
	        return new PreferenceInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.word = source["word"];
	        this.organId = source["organId"];
	        this.typeName = source["typeName"];
	    }
	}
	export class PreferenceInfoList {
	    list: PreferenceInfo[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new PreferenceInfoList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], PreferenceInfo);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class PreferenceListReq {
	    page: number;
	    size: number;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new PreferenceListReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.page = source["page"];
	        this.size = source["size"];
	        this.organId = source["organId"];
	    }
	}
	export class PreferenceListResp {
	    code: number;
	    msg: string;
	    data: PreferenceInfoList;
	
	    static createFrom(source: any = {}) {
	        return new PreferenceListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], PreferenceInfoList);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class PreferenceReq {
	    id: number;
	    word: string;
	    organId: number;
	    typeName: string;
	
	    static createFrom(source: any = {}) {
	        return new PreferenceReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.word = source["word"];
	        this.organId = source["organId"];
	        this.typeName = source["typeName"];
	    }
	}
	export class PreferenceResp {
	    data: PreferenceReq;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new PreferenceResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], PreferenceReq);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ProductTemplateForApi {
	    id: number;
	    categoryId: number;
	    categoryName: string;
	    typeId: number;
	    typeName: string;
	    templateId: number;
	
	    static createFrom(source: any = {}) {
	        return new ProductTemplateForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.categoryId = source["categoryId"];
	        this.categoryName = source["categoryName"];
	        this.typeId = source["typeId"];
	        this.typeName = source["typeName"];
	        this.templateId = source["templateId"];
	    }
	}
	
	
	export class ProviderToOpticianAuthInfo {
	    authCode: string;
	    providerId: number;
	
	    static createFrom(source: any = {}) {
	        return new ProviderToOpticianAuthInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.authCode = source["authCode"];
	        this.providerId = source["providerId"];
	    }
	}
	
	
	
	export class RegionInfo {
	    regionId: number;
	    regionName: string;
	    projectId: number;
	    regionResult: string;
	
	    static createFrom(source: any = {}) {
	        return new RegionInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.regionId = source["regionId"];
	        this.regionName = source["regionName"];
	        this.projectId = source["projectId"];
	        this.regionResult = source["regionResult"];
	    }
	}
	export class QueryRegionData {
	    regionInfos: RegionInfo[];
	    aiid: string;
	    aiResult: string;
	    editResult: string;
	
	    static createFrom(source: any = {}) {
	        return new QueryRegionData(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.regionInfos = this.convertValues(source["regionInfos"], RegionInfo);
	        this.aiid = source["aiid"];
	        this.aiResult = source["aiResult"];
	        this.editResult = source["editResult"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class QueryRegionDataResp {
	    code: number;
	    msg: string;
	    data: QueryRegionData;
	
	    static createFrom(source: any = {}) {
	        return new QueryRegionDataResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], QueryRegionData);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class QueryRegionReq {
	    checklistId: number;
	    projectIds: number[];
	
	    static createFrom(source: any = {}) {
	        return new QueryRegionReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.checklistId = source["checklistId"];
	        this.projectIds = source["projectIds"];
	    }
	}
	
	export class RankingResp {
	    data: ListRanking;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new RankingResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], ListRanking);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	
	export class RelativeBaseForListForRespForApi {
	    id: number;
	    code: string;
	    name: string;
	    sex: number;
	
	    static createFrom(source: any = {}) {
	        return new RelativeBaseForListForRespForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.code = source["code"];
	        this.name = source["name"];
	        this.sex = source["sex"];
	    }
	}
	export class RelativeBaseForListForRespForApiList {
	    list: RelativeBaseForListForRespForApi[];
	
	    static createFrom(source: any = {}) {
	        return new RelativeBaseForListForRespForApiList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], RelativeBaseForListForRespForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class RelativeBaseForListForRespForApiListResp {
	    code: number;
	    msg: string;
	    data: RelativeBaseForListForRespForApiList;
	
	    static createFrom(source: any = {}) {
	        return new RelativeBaseForListForRespForApiListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], RelativeBaseForListForRespForApiList);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class RemoveCustomerRelativeByIDReq {
	    id: number;
	
	    static createFrom(source: any = {}) {
	        return new RemoveCustomerRelativeByIDReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	    }
	}
	export class Checklist {
	    customerId: number;
	    customerName: string;
	    customerPhone: string;
	    relationId: number;
	    relationName: string;
	    baseRelationId: number;
	    baseRelationName: string;
	    age: number;
	    sex: number;
	    list: ChecklistDataForApi[];
	
	    static createFrom(source: any = {}) {
	        return new Checklist(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.customerId = source["customerId"];
	        this.customerName = source["customerName"];
	        this.customerPhone = source["customerPhone"];
	        this.relationId = source["relationId"];
	        this.relationName = source["relationName"];
	        this.baseRelationId = source["baseRelationId"];
	        this.baseRelationName = source["baseRelationName"];
	        this.age = source["age"];
	        this.sex = source["sex"];
	        this.list = this.convertValues(source["list"], ChecklistDataForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ReportCheckListResp {
	    code: number;
	    msg: string;
	    list: Checklist[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new ReportCheckListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.list = this.convertValues(source["list"], Checklist);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ReportDataForApi {
	    id: number;
	    createdAt: string;
	    updatedAt: string;
	    templateId: number;
	    visitorId: number;
	    reportPeopleName: string;
	    phoneNumber: string;
	    reportPeopleAge: number;
	    reportPeopleSex: number;
	    reportPdf: string;
	    opinionInfo: string;
	    sessionId: string;
	    projectId: number;
	    projectName: string;
	    code: string;
	    isUse: number;
	
	    static createFrom(source: any = {}) {
	        return new ReportDataForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.createdAt = source["createdAt"];
	        this.updatedAt = source["updatedAt"];
	        this.templateId = source["templateId"];
	        this.visitorId = source["visitorId"];
	        this.reportPeopleName = source["reportPeopleName"];
	        this.phoneNumber = source["phoneNumber"];
	        this.reportPeopleAge = source["reportPeopleAge"];
	        this.reportPeopleSex = source["reportPeopleSex"];
	        this.reportPdf = source["reportPdf"];
	        this.opinionInfo = source["opinionInfo"];
	        this.sessionId = source["sessionId"];
	        this.projectId = source["projectId"];
	        this.projectName = source["projectName"];
	        this.code = source["code"];
	        this.isUse = source["isUse"];
	    }
	}
	export class ReportDataForApiList {
	    list: ReportDataForApi[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new ReportDataForApiList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], ReportDataForApi);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ReportDataForApiListResp {
	    data: ReportDataForApiList;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new ReportDataForApiListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], ReportDataForApiList);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ReportInfoForApiOne {
	    id: number;
	    customRelativeId: number;
	    projectName: string;
	    templateId: number;
	    sort: number;
	    resultData: string;
	    organId: number;
	    name: string;
	    phone: string;
	    age: number;
	    sex: number;
	    listId: number;
	    resultInfo: string;
	    templateApi: string;
	
	    static createFrom(source: any = {}) {
	        return new ReportInfoForApiOne(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.customRelativeId = source["customRelativeId"];
	        this.projectName = source["projectName"];
	        this.templateId = source["templateId"];
	        this.sort = source["sort"];
	        this.resultData = source["resultData"];
	        this.organId = source["organId"];
	        this.name = source["name"];
	        this.phone = source["phone"];
	        this.age = source["age"];
	        this.sex = source["sex"];
	        this.listId = source["listId"];
	        this.resultInfo = source["resultInfo"];
	        this.templateApi = source["templateApi"];
	    }
	}
	export class ReportPdfForApi {
	    reportPdf: string;
	
	    static createFrom(source: any = {}) {
	        return new ReportPdfForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.reportPdf = source["reportPdf"];
	    }
	}
	export class ReportPdfForApiResp {
	    code: number;
	    msg: string;
	    data: ReportPdfForApi;
	
	    static createFrom(source: any = {}) {
	        return new ReportPdfForApiResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], ReportPdfForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ReportResultDataReq {
	    Page: number;
	    Size: number;
	    Query: string;
	    OrganId: number;
	    IsCustomize: number;
	    IsDefmod: number;
	    ProjectName: string;
	    Status: number;
	
	    static createFrom(source: any = {}) {
	        return new ReportResultDataReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.Page = source["Page"];
	        this.Size = source["Size"];
	        this.Query = source["Query"];
	        this.OrganId = source["OrganId"];
	        this.IsCustomize = source["IsCustomize"];
	        this.IsDefmod = source["IsDefmod"];
	        this.ProjectName = source["ProjectName"];
	        this.Status = source["Status"];
	    }
	}
	export class ResultDataItem {
	    resultData: string;
	    resultDataCn: string;
	
	    static createFrom(source: any = {}) {
	        return new ResultDataItem(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.resultData = source["resultData"];
	        this.resultDataCn = source["resultDataCn"];
	    }
	}
	export class ReportResultList {
	    list: ResultDataItem[];
	
	    static createFrom(source: any = {}) {
	        return new ReportResultList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], ResultDataItem);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ReportResultResp {
	    code: number;
	    msg: string;
	    data: ReportResultList;
	
	    static createFrom(source: any = {}) {
	        return new ReportResultResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], ReportResultList);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ResultDataForApi {
	    id: number;
	    customId: number;
	    customRelativeId: number;
	    name: string;
	    phone: string;
	    sex: number;
	    age: number;
	    dataListInfo: string;
	    visitorId: string;
	    sessionId: string;
	    resultData: string;
	    resultDataCn: string;
	    projectId: number;
	    projectName: string;
	    templateId: number;
	    sort: number;
	    typeName: string;
	    listId: number;
	    productId: number;
	    reportPdf: string;
	    deviceSn: string;
	    organId: number;
	    mongoId: string;
	    reqType: number;
	    listCode: string;
	    createdAt: string;
	    updatedAt: string;
	
	    static createFrom(source: any = {}) {
	        return new ResultDataForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.customId = source["customId"];
	        this.customRelativeId = source["customRelativeId"];
	        this.name = source["name"];
	        this.phone = source["phone"];
	        this.sex = source["sex"];
	        this.age = source["age"];
	        this.dataListInfo = source["dataListInfo"];
	        this.visitorId = source["visitorId"];
	        this.sessionId = source["sessionId"];
	        this.resultData = source["resultData"];
	        this.resultDataCn = source["resultDataCn"];
	        this.projectId = source["projectId"];
	        this.projectName = source["projectName"];
	        this.templateId = source["templateId"];
	        this.sort = source["sort"];
	        this.typeName = source["typeName"];
	        this.listId = source["listId"];
	        this.productId = source["productId"];
	        this.reportPdf = source["reportPdf"];
	        this.deviceSn = source["deviceSn"];
	        this.organId = source["organId"];
	        this.mongoId = source["mongoId"];
	        this.reqType = source["reqType"];
	        this.listCode = source["listCode"];
	        this.createdAt = source["createdAt"];
	        this.updatedAt = source["updatedAt"];
	    }
	}
	export class ResultDataForApiList {
	    list: ResultDataForApi[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new ResultDataForApiList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], ResultDataForApi);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ResultDataForApiResp {
	    code: number;
	    msg: string;
	    data: ResultDataForApiList;
	
	    static createFrom(source: any = {}) {
	        return new ResultDataForApiResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], ResultDataForApiList);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	
	export class ResultInfoReq {
	    resultData: string;
	    resultDataList: string[];
	
	    static createFrom(source: any = {}) {
	        return new ResultInfoReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.resultData = source["resultData"];
	        this.resultDataList = source["resultDataList"];
	    }
	}
	export class ResultListReq {
	    Name: string;
	    Phone: string;
	    DeviceSn: string;
	    ProjectId: number;
	    OrganId: number;
	    StartDate: string;
	    EndDate: string;
	    Page: number;
	    Size: number;
	
	    static createFrom(source: any = {}) {
	        return new ResultListReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.Name = source["Name"];
	        this.Phone = source["Phone"];
	        this.DeviceSn = source["DeviceSn"];
	        this.ProjectId = source["ProjectId"];
	        this.OrganId = source["OrganId"];
	        this.StartDate = source["StartDate"];
	        this.EndDate = source["EndDate"];
	        this.Page = source["Page"];
	        this.Size = source["Size"];
	    }
	}
	export class ResultTrendInfoList {
	    list: ResultInfoReq[];
	    timestamp: number[];
	
	    static createFrom(source: any = {}) {
	        return new ResultTrendInfoList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], ResultInfoReq);
	        this.timestamp = source["timestamp"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ResultTrendInfoResp {
	    code: number;
	    msg: string;
	    data: ResultTrendInfoList;
	
	    static createFrom(source: any = {}) {
	        return new ResultTrendInfoResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], ResultTrendInfoList);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ReturnOrderItem {
	    id: number;
	    returnOrderCode: string;
	    organId: number;
	    oldOrderId: number;
	    oldOrderCode: string;
	    oldOrderItemId: number;
	    newOrderItemId: number;
	    returnAmount: number;
	    quantity: number;
	    returnType: number;
	    remark: string;
	    createTime: string;
	
	    static createFrom(source: any = {}) {
	        return new ReturnOrderItem(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.returnOrderCode = source["returnOrderCode"];
	        this.organId = source["organId"];
	        this.oldOrderId = source["oldOrderId"];
	        this.oldOrderCode = source["oldOrderCode"];
	        this.oldOrderItemId = source["oldOrderItemId"];
	        this.newOrderItemId = source["newOrderItemId"];
	        this.returnAmount = source["returnAmount"];
	        this.quantity = source["quantity"];
	        this.returnType = source["returnType"];
	        this.remark = source["remark"];
	        this.createTime = source["createTime"];
	    }
	}
	export class ReturnOrderList {
	    list: ReturnOrderItem[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new ReturnOrderList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], ReturnOrderItem);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ReturnOrderListResp {
	    data: ReturnOrderList;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new ReturnOrderListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], ReturnOrderList);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class SendMessageToDevicesReq {
	    organId: number;
	    projectIdList: number[];
	    scan: string;
	
	    static createFrom(source: any = {}) {
	        return new SendMessageToDevicesReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.organId = source["organId"];
	        this.projectIdList = source["projectIdList"];
	        this.scan = source["scan"];
	    }
	}
	export class SendMessageToDevicesResp {
	    code: number;
	    msg: string;
	    data: DeviceDataPayloadList;
	
	    static createFrom(source: any = {}) {
	        return new SendMessageToDevicesResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], DeviceDataPayloadList);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ShipStatisticQueryReq {
	    TypeId: number;
	    GeneralId: number;
	    TimeFlag: number;
	    Name: string;
	    OrganizeId: number;
	
	    static createFrom(source: any = {}) {
	        return new ShipStatisticQueryReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.TypeId = source["TypeId"];
	        this.GeneralId = source["GeneralId"];
	        this.TimeFlag = source["TimeFlag"];
	        this.Name = source["Name"];
	        this.OrganizeId = source["OrganizeId"];
	    }
	}
	export class StatisticCommonMap {
	    list: Record<string, number>;
	
	    static createFrom(source: any = {}) {
	        return new StatisticCommonMap(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = source["list"];
	    }
	}
	export class ShipStatisticQueryResp {
	    data: StatisticCommonMap;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new ShipStatisticQueryResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], StatisticCommonMap);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	
	
	
	export class StyleInfoForApi {
	    id: number;
	    organId: number;
	    headerImg: string;
	    footerImg: string;
	    reportTitle: string;
	    deviceSn: string;
	    status: number;
	    name: string;
	    phoneNumber: string;
	
	    static createFrom(source: any = {}) {
	        return new StyleInfoForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.organId = source["organId"];
	        this.headerImg = source["headerImg"];
	        this.footerImg = source["footerImg"];
	        this.reportTitle = source["reportTitle"];
	        this.deviceSn = source["deviceSn"];
	        this.status = source["status"];
	        this.name = source["name"];
	        this.phoneNumber = source["phoneNumber"];
	    }
	}
	export class StyleInfoForApiList {
	    list: StyleInfoForApi[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new StyleInfoForApiList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], StyleInfoForApi);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class StyleInfoForApiListResp {
	    code: number;
	    msg: string;
	    data: StyleInfoForApiList;
	
	    static createFrom(source: any = {}) {
	        return new StyleInfoForApiListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], StyleInfoForApiList);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class TemplateListForApi {
	    list: any;
	    total: number;
	    productsList: ProductTemplateForApi[];
	
	    static createFrom(source: any = {}) {
	        return new TemplateListForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = source["list"];
	        this.total = source["total"];
	        this.productsList = this.convertValues(source["productsList"], ProductTemplateForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class TemplateListForApiResp {
	    code: number;
	    msg: string;
	    data: TemplateListForApi;
	
	    static createFrom(source: any = {}) {
	        return new TemplateListForApiResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], TemplateListForApi);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class TemplateListReq {
	    TemplateName: string;
	    StartDate: string;
	    EndDate: string;
	    Page: number;
	    Size: number;
	
	    static createFrom(source: any = {}) {
	        return new TemplateListReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.TemplateName = source["TemplateName"];
	        this.StartDate = source["StartDate"];
	        this.EndDate = source["EndDate"];
	        this.Page = source["Page"];
	        this.Size = source["Size"];
	    }
	}
	export class TodoForVisitReq {
	    customerId: number;
	    visitId: number;
	
	    static createFrom(source: any = {}) {
	        return new TodoForVisitReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.customerId = source["customerId"];
	        this.visitId = source["visitId"];
	    }
	}
	
	export class TrainPlanCreateReq {
	    listId: number;
	    age: number;
	
	    static createFrom(source: any = {}) {
	        return new TrainPlanCreateReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.listId = source["listId"];
	        this.age = source["age"];
	    }
	}
	export class TrainPlanDetailReq {
	    listId: number;
	
	    static createFrom(source: any = {}) {
	        return new TrainPlanDetailReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.listId = source["listId"];
	    }
	}
	export class TrainPlanItemInfo {
	    id: number;
	    planCode: string;
	    typeCode: number;
	    typeName: string;
	    classCode: number;
	    className: string;
	    state: number;
	    time: number;
	    paramObj: any;
	    paramFields: string[];
	    resultObj: any;
	    idx: number;
	
	    static createFrom(source: any = {}) {
	        return new TrainPlanItemInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.planCode = source["planCode"];
	        this.typeCode = source["typeCode"];
	        this.typeName = source["typeName"];
	        this.classCode = source["classCode"];
	        this.className = source["className"];
	        this.state = source["state"];
	        this.time = source["time"];
	        this.paramObj = source["paramObj"];
	        this.paramFields = source["paramFields"];
	        this.resultObj = source["resultObj"];
	        this.idx = source["idx"];
	    }
	}
	export class TrainPlanDetailResp {
	    list: TrainPlanItemInfo[];
	    planType: string;
	    createdAt: string;
	
	    static createFrom(source: any = {}) {
	        return new TrainPlanDetailResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], TrainPlanItemInfo);
	        this.planType = source["planType"];
	        this.createdAt = source["createdAt"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class TrainPlanDetailResp2 {
	    data: TrainPlanDetailResp;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new TrainPlanDetailResp2(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], TrainPlanDetailResp);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	
	
	export class TrendReq {
	    name: string;
	    phone: string;
	    organId: number;
	    timeType: number;
	    resultData: string[];
	
	    static createFrom(source: any = {}) {
	        return new TrendReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.name = source["name"];
	        this.phone = source["phone"];
	        this.organId = source["organId"];
	        this.timeType = source["timeType"];
	        this.resultData = source["resultData"];
	    }
	}
	
	export class UpdateCustomerForApi {
	    id: number;
	    customerName: string;
	    sex: number;
	    birthday: number;
	    nickname: string;
	    headUrl: string;
	    address: string;
	    customerSource: string;
	    accountSource: string;
	    remark: string;
	    customerCode: string;
	    occupationCode: string;
	    occupationName: string;
	    workEnvCode: string;
	    workEnvName: string;
	    eyeUsageDistanceCode: string;
	    eyeUsageDistanceName: string;
	
	    static createFrom(source: any = {}) {
	        return new UpdateCustomerForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.customerName = source["customerName"];
	        this.sex = source["sex"];
	        this.birthday = source["birthday"];
	        this.nickname = source["nickname"];
	        this.headUrl = source["headUrl"];
	        this.address = source["address"];
	        this.customerSource = source["customerSource"];
	        this.accountSource = source["accountSource"];
	        this.remark = source["remark"];
	        this.customerCode = source["customerCode"];
	        this.occupationCode = source["occupationCode"];
	        this.occupationName = source["occupationName"];
	        this.workEnvCode = source["workEnvCode"];
	        this.workEnvName = source["workEnvName"];
	        this.eyeUsageDistanceCode = source["eyeUsageDistanceCode"];
	        this.eyeUsageDistanceName = source["eyeUsageDistanceName"];
	    }
	}
	export class UpdateCustomerTrainCountReq {
	    customerId: number;
	    trainCount: number;
	
	    static createFrom(source: any = {}) {
	        return new UpdateCustomerTrainCountReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.customerId = source["customerId"];
	        this.trainCount = source["trainCount"];
	    }
	}
	export class UpdateDeviceNameReq {
	    id: number;
	    deviceName: string;
	    outCode: string;
	    status: number;
	    isBinding: number;
	    deviceSn: string;
	    bindingOrganization: string;
	    brandId: number;
	    goodsId: number;
	    brandName: string;
	    categoryId: number;
	    categoryName: string;
	    typeId: number;
	    typeName: string;
	    dealerCompanyName: string;
	
	    static createFrom(source: any = {}) {
	        return new UpdateDeviceNameReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.deviceName = source["deviceName"];
	        this.outCode = source["outCode"];
	        this.status = source["status"];
	        this.isBinding = source["isBinding"];
	        this.deviceSn = source["deviceSn"];
	        this.bindingOrganization = source["bindingOrganization"];
	        this.brandId = source["brandId"];
	        this.goodsId = source["goodsId"];
	        this.brandName = source["brandName"];
	        this.categoryId = source["categoryId"];
	        this.categoryName = source["categoryName"];
	        this.typeId = source["typeId"];
	        this.typeName = source["typeName"];
	        this.dealerCompanyName = source["dealerCompanyName"];
	    }
	}
	export class UpdateGlassesStorePurchaseOrderReqForApi {
	    glassesStorePurchaseOrder: GlassesStorePurchaseOrderForApi;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new UpdateGlassesStorePurchaseOrderReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.glassesStorePurchaseOrder = this.convertValues(source["glassesStorePurchaseOrder"], GlassesStorePurchaseOrderForApi);
	        this.organId = source["organId"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class UpdateOrganizeDepartmentReqForApi {
	    id: number;
	    departmentName: string;
	    remark: string;
	
	    static createFrom(source: any = {}) {
	        return new UpdateOrganizeDepartmentReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.departmentName = source["departmentName"];
	        this.remark = source["remark"];
	    }
	}
	export class UpdateOrganizeEmployeeReq {
	    id: number;
	    idCard: string;
	    name: string;
	    sex: number;
	    headUrl: string;
	    userName: string;
	    certificateUrl: string;
	    departmentPositionList: DepartmentPositionItem[];
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new UpdateOrganizeEmployeeReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.idCard = source["idCard"];
	        this.name = source["name"];
	        this.sex = source["sex"];
	        this.headUrl = source["headUrl"];
	        this.userName = source["userName"];
	        this.certificateUrl = source["certificateUrl"];
	        this.departmentPositionList = this.convertValues(source["departmentPositionList"], DepartmentPositionItem);
	        this.organId = source["organId"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class UpdateRegionResultReq {
	    listId: number;
	    listCode: string;
	    customId: number;
	    customRelativeId: number;
	    baseRelationId: number;
	    organizetionId: number;
	    name: string;
	    phone: string;
	    age: number;
	    sex: number;
	    dataPayload: RegionInfo[];
	    scan: string;
	
	    static createFrom(source: any = {}) {
	        return new UpdateRegionResultReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.listId = source["listId"];
	        this.listCode = source["listCode"];
	        this.customId = source["customId"];
	        this.customRelativeId = source["customRelativeId"];
	        this.baseRelationId = source["baseRelationId"];
	        this.organizetionId = source["organizetionId"];
	        this.name = source["name"];
	        this.phone = source["phone"];
	        this.age = source["age"];
	        this.sex = source["sex"];
	        this.dataPayload = this.convertValues(source["dataPayload"], RegionInfo);
	        this.scan = source["scan"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class UpdateResultReq {
	    id: number;
	    deviceSn: string;
	    listId: number;
	
	    static createFrom(source: any = {}) {
	        return new UpdateResultReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.deviceSn = source["deviceSn"];
	        this.listId = source["listId"];
	    }
	}
	export class UpdateVisitCycleCycleReqForApi {
	    customerId: number;
	    visitCycleDays: number;
	    whyVisit: string;
	    organId: number;
	
	    static createFrom(source: any = {}) {
	        return new UpdateVisitCycleCycleReqForApi(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.customerId = source["customerId"];
	        this.visitCycleDays = source["visitCycleDays"];
	        this.whyVisit = source["whyVisit"];
	        this.organId = source["organId"];
	    }
	}
	
	export class UseAiGenerateContentReq {
	    UniqueId: string;
	    isUse: number;
	
	    static createFrom(source: any = {}) {
	        return new UseAiGenerateContentReq(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.UniqueId = source["UniqueId"];
	        this.isUse = source["isUse"];
	    }
	}
	export class UserInfo {
	    id: number;
	    createdTime: number;
	    updatedTime: number;
	    uniqueNumber: string;
	    username: string;
	    organizationId: number;
	    weChatUnionid: string;
	    organizationCode: string;
	    nickName: string;
	    headerImg: string;
	    phone: string;
	    status: boolean;
	    seckey: string;
	    email: string;
	
	    static createFrom(source: any = {}) {
	        return new UserInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.createdTime = source["createdTime"];
	        this.updatedTime = source["updatedTime"];
	        this.uniqueNumber = source["uniqueNumber"];
	        this.username = source["username"];
	        this.organizationId = source["organizationId"];
	        this.weChatUnionid = source["weChatUnionid"];
	        this.organizationCode = source["organizationCode"];
	        this.nickName = source["nickName"];
	        this.headerImg = source["headerImg"];
	        this.phone = source["phone"];
	        this.status = source["status"];
	        this.seckey = source["seckey"];
	        this.email = source["email"];
	    }
	}
	export class UserInfoResp {
	    code: number;
	    msg: string;
	    data: UserInfo;
	
	    static createFrom(source: any = {}) {
	        return new UserInfoResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], UserInfo);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class VisitRecordForList {
	    id: number;
	    customerName: string;
	    customerTel: string;
	    estimatedVisitTimeFormat: string;
	    actualVisitTimeFormat: string;
	    isVisited: number;
	    visitMethod: number;
	    visitResult: string;
	
	    static createFrom(source: any = {}) {
	        return new VisitRecordForList(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.customerName = source["customerName"];
	        this.customerTel = source["customerTel"];
	        this.estimatedVisitTimeFormat = source["estimatedVisitTimeFormat"];
	        this.actualVisitTimeFormat = source["actualVisitTimeFormat"];
	        this.isVisited = source["isVisited"];
	        this.visitMethod = source["visitMethod"];
	        this.visitResult = source["visitResult"];
	    }
	}
	export class VisitRecordForListRes {
	    data: VisitRecordForList;
	    code: number;
	    msg: string;
	
	    static createFrom(source: any = {}) {
	        return new VisitRecordForListRes(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], VisitRecordForList);
	        this.code = source["code"];
	        this.msg = source["msg"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class VisitRecordForListResp {
	    list: VisitRecordForList[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new VisitRecordForListResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], VisitRecordForList);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class VisitRecordForListRespResp {
	    code: number;
	    msg: string;
	    data: VisitRecordForListResp;
	
	    static createFrom(source: any = {}) {
	        return new VisitRecordForListRespResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], VisitRecordForListResp);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class WxCustomDeviceId {
	    id: number;
	    organizeId: number;
	
	    static createFrom(source: any = {}) {
	        return new WxCustomDeviceId(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.organizeId = source["organizeId"];
	    }
	}
	export class WxDeviceInfo {
	    id: number;
	    deviceSn: string;
	    goodsId: number;
	    outCode: string;
	    deviceName: string;
	    brandName: string;
	    categoryName: string;
	    typeName: string;
	    brandId: number;
	    typeId: number;
	    categoryId: number;
	    status: number;
	    isBinding: number;
	    bindingOrganization: string;
	    tagsDescription: string;
	    dealerCompanyName: string;
	
	    static createFrom(source: any = {}) {
	        return new WxDeviceInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.deviceSn = source["deviceSn"];
	        this.goodsId = source["goodsId"];
	        this.outCode = source["outCode"];
	        this.deviceName = source["deviceName"];
	        this.brandName = source["brandName"];
	        this.categoryName = source["categoryName"];
	        this.typeName = source["typeName"];
	        this.brandId = source["brandId"];
	        this.typeId = source["typeId"];
	        this.categoryId = source["categoryId"];
	        this.status = source["status"];
	        this.isBinding = source["isBinding"];
	        this.bindingOrganization = source["bindingOrganization"];
	        this.tagsDescription = source["tagsDescription"];
	        this.dealerCompanyName = source["dealerCompanyName"];
	    }
	}
	export class WxDeviceTagQuery {
	    subordinateOrganizeId: number;
	    page: number;
	    pageSize: number;
	    organizeId: number;
	    isBinding: number;
	
	    static createFrom(source: any = {}) {
	        return new WxDeviceTagQuery(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.subordinateOrganizeId = source["subordinateOrganizeId"];
	        this.page = source["page"];
	        this.pageSize = source["pageSize"];
	        this.organizeId = source["organizeId"];
	        this.isBinding = source["isBinding"];
	    }
	}
	export class WxHeadClassRegisterDeviceInfo {
	    outCode: string;
	    categoryId: number;
	    categoryName: string;
	    typeId: number;
	    typeName: string;
	    brandName: string;
	    brandId: number;
	    deviceName: string;
	
	    static createFrom(source: any = {}) {
	        return new WxHeadClassRegisterDeviceInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.outCode = source["outCode"];
	        this.categoryId = source["categoryId"];
	        this.categoryName = source["categoryName"];
	        this.typeId = source["typeId"];
	        this.typeName = source["typeName"];
	        this.brandName = source["brandName"];
	        this.brandId = source["brandId"];
	        this.deviceName = source["deviceName"];
	    }
	}
	export class WxListDevice {
	    list: WxDeviceInfo[];
	    total: number;
	
	    static createFrom(source: any = {}) {
	        return new WxListDevice(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], WxDeviceInfo);
	        this.total = source["total"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class WxListDeviceResp {
	    code: number;
	    msg: string;
	    data: WxListDevice;
	
	    static createFrom(source: any = {}) {
	        return new WxListDeviceResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = this.convertValues(source["data"], WxListDevice);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}

}

